@loaders.gl/ply 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/workers/ply-worker.js

@@ -1,4 +1,5 @@
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-import { PLYLoader } from '../index';
-createLoaderWorker(PLYLoader);
-//# sourceMappingURL=ply-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const index_1 = require("../index");
+(0, loader_utils_1.createLoaderWorker)(index_1.PLYLoader);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/ply",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.6",
   "description": "Framework-independent loader for the PLY format",
   "license": "MIT",
   "publishConfig": {
@@ -19,8 +19,8 @@
     "PLY"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -34,8 +34,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
-    "@loaders.gl/schema": "4.0.0-alpha.5"
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/schema": "4.0.0-alpha.6"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/index.ts

@@ -1,22 +1,27 @@
-import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {PLYMesh} from './lib/ply-types';
 import {PLYLoader as PLYWorkerLoader} from './ply-loader';
-import parsePLY from './lib/parse-ply';
-import parsePLYInBatches from './lib/parse-ply-in-batches';
+import {ParsePLYOptions, parsePLY} from './lib/parse-ply';
+import {parsePLYInBatches} from './lib/parse-ply-in-batches';
 
 // PLYLoader
 
 export {PLYWorkerLoader};
 
+export type PLYLoaderOptions = LoaderOptions & {
+  ply?: ParsePLYOptions;
+};
+
 /**
  * Loader for PLY - Polygon File Format
  */
-export const PLYLoader = {
+export const PLYLoader: LoaderWithParser<PLYMesh, any, PLYLoaderOptions> = {
   ...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/get-ply-schema.ts

@@ -8,8 +8,8 @@ import type {PLYHeader} from './ply-types';
  * @returns Schema
  */
 export function getPLYSchema(plyHeader: PLYHeader, attributes: MeshAttributes): Schema {
-  const metadataMap = makeMetadataFromPlyHeader(plyHeader);
-  const schema = deduceMeshSchema(attributes, metadataMap);
+  const metadata = makeMetadataFromPlyHeader(plyHeader);
+  const schema = deduceMeshSchema(attributes, metadata);
   return schema;
 }
 
@@ -18,18 +18,19 @@ export function getPLYSchema(plyHeader: PLYHeader, attributes: MeshAttributes):
  * @param plyHeader
  * @returns
  */
-function makeMetadataFromPlyHeader(plyHeader: PLYHeader): Map<string, string> {
-  const metadataMap = new Map();
-  metadataMap.set('ply_comments', JSON.stringify(plyHeader.comments));
-  metadataMap.set('ply_elements', JSON.stringify(plyHeader.elements));
+function makeMetadataFromPlyHeader(plyHeader: PLYHeader): Record<string, string> {
+  /* eslint-disable camelcase */
+  const metadata: Record<string, string> = {};
+  metadata.ply_comments = JSON.stringify(plyHeader.comments);
+  metadata.ply_elements = JSON.stringify(plyHeader.elements);
   if (plyHeader.format !== undefined) {
-    metadataMap.set('ply_format', plyHeader.format);
+    metadata.ply_format = plyHeader.format;
   }
   if (plyHeader.version !== undefined) {
-    metadataMap.set('ply_version', plyHeader.version);
+    metadata.ply_version = plyHeader.version;
   }
   if (plyHeader.headerLength !== undefined) {
-    metadataMap.set('ply_headerLength', plyHeader.headerLength.toString(10));
+    metadata.ply_headerLength = plyHeader.headerLength.toString(10);
   }
-  return metadataMap;
+  return metadata;
 }

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 = {};

package/src/lib/parse-ply.ts

@@ -25,17 +25,21 @@ import type {
   PLYHeader,
   PLYAttributes,
   MeshHeader,
-  ASCIIElement,
+  PLYElement,
   PLYProperty
 } from './ply-types';
 import normalizePLY from './normalize-ply';
 
+export type ParsePLYOptions = {
+  propertyNameMapping?: Record<string, string>;
+};
+
 /**
  * @param data
  * @param options
  * @returns
  */
-export default function parsePLY(data: ArrayBuffer | string, options = {}): PLYMesh {
+export function parsePLY(data: ArrayBuffer | string, options: ParsePLYOptions = {}): PLYMesh {
   let header: PLYHeader & MeshHeader;
   let attributes: PLYAttributes;
 
@@ -56,7 +60,7 @@ export default function parsePLY(data: ArrayBuffer | string, options = {}): PLYM
  * @param options
  * @returns header
  */
-function parseHeader(data: any, options: {[index: string]: any}): PLYHeader {
+function parseHeader(data: any, options?: ParsePLYOptions): PLYHeader {
   const PLY_HEADER_PATTERN = /ply([\s\S]*)end_header\s/;
 
   let headerText = '';
@@ -80,10 +84,11 @@ function parseHeader(data: any, options: {[index: string]: any}): PLYHeader {
  * @param options
  * @returns header
  */
+// eslint-disable-next-line complexity
 function parseHeaderLines(
   lines: string[],
   headerLength: number,
-  options: {[index: string]: any}
+  options?: ParsePLYOptions
 ): PLYHeader {
   const header: PLYHeader = {
     comments: [],
@@ -93,7 +98,7 @@ function parseHeaderLines(
 
   let lineType: string | undefined;
   let lineValues: string[];
-  let currentElement: ASCIIElement | null = null;
+  let currentElement: PLYElement | null = null;
 
   for (let i = 0; i < lines.length; i++) {
     let line: string = lines[i];
@@ -119,6 +124,7 @@ function parseHeaderLines(
         break;
 
       case 'element':
+        // Start new element, store previous element
         if (currentElement) {
           header.elements.push(currentElement);
         }
@@ -131,12 +137,13 @@ function parseHeaderLines(
         break;
 
       case 'property':
-        if (!currentElement) {
-          break;
+        if (currentElement) {
+          const property = makePLYElementProperty(lineValues);
+          if (options?.propertyNameMapping && property.name in options?.propertyNameMapping) {
+            property.name = options?.propertyNameMapping[property.name];
+          }
+          currentElement.properties.push(property);
         }
-        currentElement.properties.push(
-          makePLYElementProperty(lineValues, options.propertyNameMapping)
-        );
         break;
 
       default:
@@ -145,36 +152,74 @@ function parseHeaderLines(
     }
   }
 
-  if (currentElement !== undefined) {
+  // Store in-progress element
+  if (currentElement) {
     header.elements.push(currentElement);
   }
 
   return header;
 }
 
-/**
- * @param propertValues
- * @param propertyNameMapping
- * @returns property of ply element
- */
-function makePLYElementProperty(propertValues: string[], propertyNameMapping: []): PLYProperty {
-  const property: PLYProperty = {
-    type: propertValues[0]
+/** Generate attributes arrays from the header */
+// eslint-disable-next-line complexity
+function getPLYAttributes(header: PLYHeader): PLYAttributes {
+  // TODO Generate only the attribute arrays actually in the 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:
+            // Add any non-geometry attributes
+            attributes[property.name] = [];
+            break;
+        }
+      }
+    }
   }
 
-  if (propertyNameMapping && property.name in propertyNameMapping) {
-    property.name = propertyNameMapping[property.name];
-  }
+  return attributes;
+}
 
-  return property;
+/**
+ * @param propertyValues
+ * @returns property of ply element
+ */
+function makePLYElementProperty(propertyValues: string[]): 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]
+      };
+  }
 }
 
 /**
@@ -216,7 +261,7 @@ function parseASCIINumber(n: string, type: string): number {
  * @param line
  * @returns ASCII element
  */
-function parseASCIIElement(properties: any[], line: string) {
+function parsePLYElement(properties: any[], line: string) {
   const values: any = line.split(/\s+/);
 
   const element = {};
@@ -247,13 +292,7 @@ function parseASCIIElement(properties: any[], line: string) {
 function parseASCII(data: any, header: PLYHeader): PLYAttributes {
   // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
 
-  const attributes: PLYAttributes = {
-    indices: [],
-    vertices: [],
-    normals: [],
-    uvs: [],
-    colors: []
-  };
+  const attributes = getPLYAttributes(header);
 
   let result: RegExpExecArray | null;
 
@@ -277,7 +316,7 @@ function parseASCII(data: any, header: PLYHeader): PLYAttributes {
         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++;
     }
@@ -298,18 +337,44 @@ function handleElement(
   element: any = {}
 ) {
   if (elementName === 'vertex') {
-    buffer.vertices.push(element.x, element.y, element.z);
+    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;
 
-    if ('nx' in element && 'ny' in element && 'nz' in element) {
-      buffer.normals.push(element.nx, element.ny, element.nz);
-    }
+        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;
 
-    if ('s' in element && 't' in element) {
-      buffer.uvs.push(element.s, element.t);
-    }
+        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;
 
-    if ('red' in element && 'green' in element && 'blue' in element) {
-      buffer.colors.push(element.red, element.green, element.blue);
+        default:
+          buffer[propertyName].push(element[propertyName]);
+      }
     }
   } else if (elementName === 'face') {
     const vertexIndices = element.vertex_indices || element.vertex_index; // issue #9338
@@ -419,14 +484,8 @@ type BinaryAttributes = {
  * @param header
  * @returns [attributes] of data
  */
-function parseBinary(data: ArrayBuffer, header: {[index: string]: any}): BinaryAttributes {
-  const attributes: BinaryAttributes = {
-    indices: [],
-    vertices: [],
-    normals: [],
-    uvs: [],
-    colors: []
-  };
+function parseBinary(data: ArrayBuffer, header: PLYHeader): BinaryAttributes {
+  const attributes = getPLYAttributes(header);
 
   const littleEndian = header.format === 'binary_little_endian';
   const body = new DataView(data, header.headerLength);

package/src/lib/ply-types.ts

@@ -1,36 +1,45 @@
+// loaders.gl, MIT license
 import type {Mesh} from '@loaders.gl/schema';
 
+/** A parsed PLY mesh */
+export type PLYMesh = Mesh & {
+  loader: 'ply';
+  loaderData: PLYHeader;
+};
+
+/** A PLY header */
 export type PLYHeader = {
   format?: string;
   comments: string[];
-  elements: any[];
+  elements: PLYElement[];
   version?: string;
   headerLength?: number;
 };
 
-/** A parsed PLY mesh */
-export type PLYMesh = Mesh & {
-  loader: 'ply';
-  loaderData: PLYHeader;
-};
-
 // INTERNAL TYPES
 
+/** A general mesh header */
 export type MeshHeader = {
   vertexCount?: number;
   boundingBox?: [[number, number, number], [number, number, number]];
 };
 
+/** The parsed columnar values */
 export type PLYAttributes = {
   [index: string]: number[];
 };
 
-export type PLYProperty = {
-  [index: string]: string;
+/** A top level PLY element (vertex, face,  ...) */
+export type PLYElement = {
+  name: string;
+  count: number;
+  properties: PLYProperty[];
 };
 
-export type ASCIIElement = {
+/** One property in a top-level PLY element */
+export type PLYProperty = {
   name: string;
-  count: number;
-  properties: any[];
+  type: string;
+  countType?: string;
+  itemType?: string;
 };

package/src/ply-loader.ts

@@ -1,5 +1,6 @@
 // PLY Loader
-import type {Loader} from '@loaders.gl/loader-utils';
+import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
+import {PLYMesh} from './lib/ply-types';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
@@ -10,11 +11,11 @@ const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
  * links: ['http://paulbourke.net/dataformats/ply/',
  * 'https://en.wikipedia.org/wiki/PLY_(file_format)']
  */
-export const PLYLoader = {
+export const PLYLoader: Loader<PLYMesh, never, LoaderOptions> = {
   name: 'PLY',
   id: 'ply',
   module: 'ply',
-  shapes: ['mesh', 'gltf', 'columnar-table'],
+  // shapes: ['mesh', 'gltf', 'columnar-table'],
   version: VERSION,
   worker: true,
   extensions: ['ply'],

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"names":["PLYLoader","PLYWorkerLoader","parsePLY","parsePLYInBatches","parse","arrayBuffer","options","parseTextSync","parseSync","parseInBatches","_typecheckPLYLoader"],"mappings":"AACA,SAAQA,SAAS,IAAIC,eAArB,QAA2C,cAA3C;AACA,OAAOC,QAAP,MAAqB,iBAArB;AACA,OAAOC,iBAAP,MAA8B,4BAA9B;AAIA,SAAQF,eAAR;AAKA,OAAO,MAAMD,SAAS,GAAG,EACvB,GAAGC,eADoB;AAGvBG,EAAAA,KAAK,EAAE,OAAOC,WAAP,EAAoBC,OAApB,KAAgCJ,QAAQ,CAACG,WAAD,EAAcC,OAAd,CAHxB;AAIvBC,EAAAA,aAAa,EAAEL,QAJQ;AAKvBM,EAAAA,SAAS,EAAEN,QALY;AAMvBO,EAAAA,cAAc,EAAEN;AANO,CAAlB;AASP,OAAO,MAAMO,mBAAqC,GAAGV,SAA9C","sourcesContent":["import type {LoaderWithParser} from '@loaders.gl/loader-utils';\nimport {PLYLoader as PLYWorkerLoader} from './ply-loader';\nimport parsePLY from './lib/parse-ply';\nimport parsePLYInBatches from './lib/parse-ply-in-batches';\n\n// PLYLoader\n\nexport {PLYWorkerLoader};\n\n/**\n * Loader for PLY - Polygon File Format\n */\nexport const PLYLoader = {\n  ...PLYWorkerLoader,\n  // Note: parsePLY supports both text and binary\n  parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options), // TODO - this may not detect text correctly?\n  parseTextSync: parsePLY,\n  parseSync: parsePLY,\n  parseInBatches: parsePLYInBatches\n};\n\nexport const _typecheckPLYLoader: LoaderWithParser = PLYLoader;\n"],"file":"index.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/lib/get-ply-schema.ts"],"names":["deduceMeshSchema","getPLYSchema","plyHeader","attributes","metadataMap","makeMetadataFromPlyHeader","schema","Map","set","JSON","stringify","comments","elements","format","undefined","version","headerLength","toString"],"mappings":"AAAA,SAAgCA,gBAAhC,QAAuD,oBAAvD;AASA,OAAO,SAASC,YAAT,CAAsBC,SAAtB,EAA4CC,UAA5C,EAAgF;AACrF,QAAMC,WAAW,GAAGC,yBAAyB,CAACH,SAAD,CAA7C;AACA,QAAMI,MAAM,GAAGN,gBAAgB,CAACG,UAAD,EAAaC,WAAb,CAA/B;AACA,SAAOE,MAAP;AACD;;AAOD,SAASD,yBAAT,CAAmCH,SAAnC,EAA8E;AAC5E,QAAME,WAAW,GAAG,IAAIG,GAAJ,EAApB;AACAH,EAAAA,WAAW,CAACI,GAAZ,CAAgB,cAAhB,EAAgCC,IAAI,CAACC,SAAL,CAAeR,SAAS,CAACS,QAAzB,CAAhC;AACAP,EAAAA,WAAW,CAACI,GAAZ,CAAgB,cAAhB,EAAgCC,IAAI,CAACC,SAAL,CAAeR,SAAS,CAACU,QAAzB,CAAhC;;AACA,MAAIV,SAAS,CAACW,MAAV,KAAqBC,SAAzB,EAAoC;AAClCV,IAAAA,WAAW,CAACI,GAAZ,CAAgB,YAAhB,EAA8BN,SAAS,CAACW,MAAxC;AACD;;AACD,MAAIX,SAAS,CAACa,OAAV,KAAsBD,SAA1B,EAAqC;AACnCV,IAAAA,WAAW,CAACI,GAAZ,CAAgB,aAAhB,EAA+BN,SAAS,CAACa,OAAzC;AACD;;AACD,MAAIb,SAAS,CAACc,YAAV,KAA2BF,SAA/B,EAA0C;AACxCV,IAAAA,WAAW,CAACI,GAAZ,CAAgB,kBAAhB,EAAoCN,SAAS,CAACc,YAAV,CAAuBC,QAAvB,CAAgC,EAAhC,CAApC;AACD;;AACD,SAAOb,WAAP;AACD","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 metadataMap = makeMetadataFromPlyHeader(plyHeader);\n  const schema = deduceMeshSchema(attributes, metadataMap);\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): Map<string, string> {\n  const metadataMap = new Map();\n  metadataMap.set('ply_comments', JSON.stringify(plyHeader.comments));\n  metadataMap.set('ply_elements', JSON.stringify(plyHeader.elements));\n  if (plyHeader.format !== undefined) {\n    metadataMap.set('ply_format', plyHeader.format);\n  }\n  if (plyHeader.version !== undefined) {\n    metadataMap.set('ply_version', plyHeader.version);\n  }\n  if (plyHeader.headerLength !== undefined) {\n    metadataMap.set('ply_headerLength', plyHeader.headerLength.toString(10));\n  }\n  return metadataMap;\n}\n"],"file":"get-ply-schema.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/lib/normalize-ply.ts"],"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","POSITION","Float32Array","normals","NORMAL","uvs","TEXCOORD_0","colors","COLOR_0","Uint8Array","normalized"],"mappings":"AACA,SAAQA,kBAAR,QAAiC,oBAAjC;AAEA,SAAQC,YAAR,QAA2B,kBAA3B;AAOA,eAAe,SAASC,YAAT,CACbC,SADa,EAEbC,aAFa,EAGbC,OAHa,EAIJ;AACT,QAAMC,UAAU,GAAGC,iBAAiB,CAACH,aAAD,CAApC;AACA,QAAMI,WAAW,GAAGR,kBAAkB,CAACM,UAAD,CAAtC;AACA,QAAMG,WAAW,GAAGL,aAAa,CAACM,OAAd,CAAsBC,MAAtB,IAAgCP,aAAa,CAACQ,QAAd,CAAuBD,MAAvB,GAAgC,CAApF;AAIA,QAAME,WAAW,GAAGT,aAAa,CAACM,OAAd,IAAyBN,aAAa,CAACM,OAAd,CAAsBC,MAAtB,GAA+B,CAA5E;AACA,QAAMG,IAAI,GAAGD,WAAW,GAAG,CAAH,GAAO,CAA/B;AACA,QAAME,QAAQ,GAAGF,WAAW,GAAG,eAAH,GAAqB,YAAjD;AAEA,QAAMG,MAAM,GAAGf,YAAY,CAACE,SAAD,EAAYG,UAAZ,CAA3B;AAEA,QAAMW,OAAgB,GAAG;AACvBC,IAAAA,MAAM,EAAE,KADe;AAEvBC,IAAAA,UAAU,EAAEhB,SAFW;AAGvBiB,IAAAA,MAAM,EAAE;AACNX,MAAAA,WADM;AAEND,MAAAA;AAFM,KAHe;AAOvBQ,IAAAA,MAPuB;AAQvBV,IAAAA,UARuB;AASvBI,IAAAA,OAAO,EAAE;AAACW,MAAAA,KAAK,EAAE,IAAIC,WAAJ,CAAgB,CAAhB,CAAR;AAA4BC,MAAAA,IAAI,EAAE;AAAlC,KATc;AAUvBT,IAAAA,IAVuB;AAWvBC,IAAAA;AAXuB,GAAzB;;AAcA,MAAIX,aAAa,CAACM,OAAd,CAAsBC,MAAtB,GAA+B,CAAnC,EAAsC;AACpCM,IAAAA,OAAO,CAACP,OAAR,GAAkB;AAACW,MAAAA,KAAK,EAAE,IAAIC,WAAJ,CAAgBlB,aAAa,CAACM,OAA9B,CAAR;AAAgDa,MAAAA,IAAI,EAAE;AAAtD,KAAlB;AACD;;AAED,SAAON,OAAP;AACD;;AAMD,SAASV,iBAAT,CAA2BD,UAA3B,EAAsE;AACpE,QAAMkB,SAAyB,GAAG,EAAlC;AAEAA,EAAAA,SAAS,CAACC,QAAV,GAAqB;AAACJ,IAAAA,KAAK,EAAE,IAAIK,YAAJ,CAAiBpB,UAAU,CAACM,QAA5B,CAAR;AAA+CW,IAAAA,IAAI,EAAE;AAArD,GAArB;;AAIA,MAAIjB,UAAU,CAACqB,OAAX,CAAmBhB,MAAnB,GAA4B,CAAhC,EAAmC;AACjCa,IAAAA,SAAS,CAACI,MAAV,GAAmB;AAACP,MAAAA,KAAK,EAAE,IAAIK,YAAJ,CAAiBpB,UAAU,CAACqB,OAA5B,CAAR;AAA8CJ,MAAAA,IAAI,EAAE;AAApD,KAAnB;AACD;;AAED,MAAIjB,UAAU,CAACuB,GAAX,CAAelB,MAAf,GAAwB,CAA5B,EAA+B;AAC7Ba,IAAAA,SAAS,CAACM,UAAV,GAAuB;AAACT,MAAAA,KAAK,EAAE,IAAIK,YAAJ,CAAiBpB,UAAU,CAACuB,GAA5B,CAAR;AAA0CN,MAAAA,IAAI,EAAE;AAAhD,KAAvB;AACD;;AAED,MAAIjB,UAAU,CAACyB,MAAX,CAAkBpB,MAAlB,GAA2B,CAA/B,EAAkC;AAEhCa,IAAAA,SAAS,CAACQ,OAAV,GAAoB;AAACX,MAAAA,KAAK,EAAE,IAAIY,UAAJ,CAAe3B,UAAU,CAACyB,MAA1B,CAAR;AAA2CR,MAAAA,IAAI,EAAE,CAAjD;AAAoDW,MAAAA,UAAU,EAAE;AAAhE,KAApB;AACD;;AAED,SAAOV,SAAP;AACD","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 */\nfunction getMeshAttributes(attributes: PLYAttributes): MeshAttributes {\n  const accessors: MeshAttributes = {};\n\n  accessors.POSITION = {value: new Float32Array(attributes.vertices), size: 3};\n\n  // optional attributes data\n\n  if (attributes.normals.length > 0) {\n    accessors.NORMAL = {value: new Float32Array(attributes.normals), size: 3};\n  }\n\n  if (attributes.uvs.length > 0) {\n    accessors.TEXCOORD_0 = {value: new Float32Array(attributes.uvs), size: 2};\n  }\n\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\n  return accessors;\n}\n"],"file":"normalize-ply.js"}