@loaders.gl/pointclouds 0.0.0-stage → 5.0.0-beta.1

package/dist/ply/lib/parse-ply-in-batches.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ply/lib/parse-ply-in-batches.ts"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// PLY Loader, adapted from THREE.js (MIT license)\n//\n// Attributions per original THREE.js source file:\n//\n// @author Wei Meng / http://about.me/menway\n//\n// Description: A loader for PLY ASCII files (known as the Polygon File Format\n// or the Stanford Triangle Format).\n//\n// Limitations: ASCII decoding assumes file is UTF-8.\n//\n// If the PLY file uses non standard property names, they can be mapped while\n// loading. For example, the following maps the properties\n// \u201Cdiffuse_(red|green|blue)\u201D in the file to standard color names.\n//\n// parsePLY(data, {\n//   propertyNameMapping: {\n//     diffuse_red: 'red',\n//     diffuse_green: 'green',\n//     diffuse_blue: 'blue'\n//   }\n// });\n\nimport {\n  makeLineIterator,\n  makeTextDecoderIterator,\n  forEach,\n  toArrayBufferIterator\n} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport normalizePLY from './normalize-ply';\nimport {PLYMesh, PLYHeader, PLYElement, PLYProperty, PLYAttributes} from './ply-types';\nimport {\n  getPLYBinaryPointCloudParsePlan,\n  parsePLYBinaryPointCloudRecordsToArrowTable,\n  parsePLYHeader,\n  type PLYBinaryPointCloudParsePlan\n} from './parse-ply';\nimport {convertPLYElementTablesToMeshArrowTable, parsePLYToElementTables} from './parse-ply-arrow';\n\ntype MutablePLYAttributes = {[index: string]: number[]};\ntype ByteArray = Uint8Array<ArrayBufferLike>;\nconst DEFAULT_BINARY_BATCH_SIZE = 65536;\nconst PLY_END_HEADER = 'end_header';\n\n/**\n * PARSER\n * @param iterator\n * @param options\n */\nexport async function* parsePLYInBatches(\n  iterator:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>,\n  options: any\n): AsyncIterable<PLYMesh | MeshArrowTable> {\n  if (options?.shape === 'arrow-table') {\n    yield* parseBinaryPLYToArrowInBatches(iterator, options);\n    return;\n  }\n\n  const lineIterator = makeLineIterator(makeTextDecoderIterator(toArrayBufferIterator(iterator)));\n  const header = await parseASCIIHeader(lineIterator, options);\n\n  let attributes: PLYAttributes;\n  switch (header.format) {\n    case 'ascii':\n      attributes = await parseASCII(lineIterator, header);\n      break;\n    default:\n      throw new Error('Binary PLY can not yet be parsed in streaming mode');\n    // attributes = await parseBinary(lineIterator, header);\n  }\n\n  yield normalizePLY(header, attributes, options);\n}\n\n/** Parse PLY vertices into Arrow table batches. */\nasync function* parseBinaryPLYToArrowInBatches(\n  iterator:\n    | AsyncIterable<ArrayBufferLike | ArrayBufferView>\n    | Iterable<ArrayBufferLike | ArrayBufferView>,\n  options: any\n): AsyncIterable<MeshArrowTable> {\n  const byteIterator = toArrayBufferIterator(iterator)[Symbol.asyncIterator]();\n  const {header, initialBodyBytes} = await readPLYHeader(byteIterator, options);\n  let tables: AsyncIterable<MeshArrowTable>;\n  if (header.format === 'ascii') {\n    tables = parseASCIIPLYToArrowInBatches(byteIterator, header, initialBodyBytes, options);\n  } else {\n    const vertexElement = getVertexElement(header, options);\n    tables = vertexElement.properties.some(property => property.type === 'list')\n      ? parseBinaryVariableWidthVertexPLYToArrowInBatches(\n          byteIterator,\n          header,\n          initialBodyBytes,\n          options\n        )\n      : parseBinaryFixedWidthVertexPLYToArrowInBatches(\n          byteIterator,\n          header,\n          initialBodyBytes,\n          options\n        );\n  }\n  for await (const table of tables) {\n    yield {...table, loaderData: header} as MeshArrowTable;\n  }\n}\n\n/** Parse fixed-width binary PLY vertices into Arrow table batches. */\nasync function* parseBinaryFixedWidthVertexPLYToArrowInBatches(\n  byteIterator: AsyncIterator<ArrayBufferLike>,\n  header: PLYHeader,\n  initialBodyBytes: ByteArray,\n  options: any\n): AsyncIterable<MeshArrowTable> {\n  const vertexElement = getFixedWidthVertexElement(header, options);\n  const batchSize = getBatchSize(options);\n  const vertexStride = getPLYElementSize(vertexElement);\n  const parsePlan = getPLYBinaryPointCloudParsePlan(header, options);\n  let remainingVertices = vertexElement.count;\n  let pendingBytes = initialBodyBytes;\n\n  while (true) {\n    while (remainingVertices > 0 && Math.floor(pendingBytes.length / vertexStride) >= batchSize) {\n      const batchVertexCount = Math.min(batchSize, remainingVertices);\n      const batch = makeBinaryPLYArrowBatch(\n        header,\n        pendingBytes,\n        batchVertexCount,\n        vertexStride,\n        options,\n        parsePlan\n      );\n      pendingBytes = pendingBytes.subarray(batchVertexCount * vertexStride);\n      remainingVertices -= batchVertexCount;\n      yield batch;\n    }\n\n    if (options?.pointCloud && remainingVertices <= 0) {\n      return;\n    }\n\n    const {value: chunk, done} = await byteIterator.next();\n    if (done) {\n      break;\n    }\n    pendingBytes = concatenateBytes([pendingBytes, getUint8Array(chunk)]);\n  }\n\n  if (remainingVertices > 0) {\n    const batchVertexCount = Math.min(\n      remainingVertices,\n      Math.floor(pendingBytes.length / vertexStride)\n    );\n    if (batchVertexCount > 0) {\n      yield makeBinaryPLYArrowBatch(\n        header,\n        pendingBytes,\n        batchVertexCount,\n        vertexStride,\n        options,\n        parsePlan\n      );\n    }\n  }\n}\n\n/** Parse ASCII vertex PLY rows into Arrow table batches. */\nasync function* parseASCIIPLYToArrowInBatches(\n  byteIterator: AsyncIterator<ArrayBufferLike>,\n  header: PLYHeader,\n  initialBodyBytes: ByteArray,\n  options: any\n): AsyncIterable<MeshArrowTable> {\n  const vertexElement = getVertexElement(header, options);\n  const batchSize = getBatchSize(options);\n  const lineIterator = makeLineIterator(\n    makeTextDecoderIterator(getByteIteratorWithInitialBytes(byteIterator, initialBodyBytes))\n  );\n  let batchLines: string[] = [];\n  let remainingVertices = vertexElement.count;\n\n  for await (const sourceLine of lineIterator) {\n    const line = sourceLine.trim();\n    if (line === '') {\n      continue;\n    }\n    batchLines.push(line);\n    remainingVertices--;\n    if (batchLines.length >= batchSize) {\n      yield makeASCIIPLYArrowBatch(header, batchLines, options);\n      batchLines = [];\n    }\n    if (remainingVertices <= 0) {\n      break;\n    }\n  }\n\n  if (batchLines.length > 0) {\n    yield makeASCIIPLYArrowBatch(header, batchLines, options);\n  }\n}\n\n/** Parse variable-width binary vertex rows into Arrow table batches. */\nasync function* parseBinaryVariableWidthVertexPLYToArrowInBatches(\n  byteIterator: AsyncIterator<ArrayBufferLike>,\n  header: PLYHeader,\n  initialBodyBytes: ByteArray,\n  options: any\n): AsyncIterable<MeshArrowTable> {\n  const vertexElement = getVertexElement(header, options);\n  const batchSize = getBatchSize(options);\n  const littleEndian = header.format !== 'binary_big_endian';\n  let remainingVertices = vertexElement.count;\n  let pendingBytes = initialBodyBytes;\n  let batchBytes: ByteArray[] = [];\n  let batchByteLength = 0;\n  let batchRowCount = 0;\n\n  while (remainingVertices > 0) {\n    const rowByteLength = getBinaryElementRowByteLength(pendingBytes, vertexElement, littleEndian);\n    if (rowByteLength === null) {\n      const {value: chunk, done} = await byteIterator.next();\n      if (done) {\n        break;\n      }\n      pendingBytes = concatenateBytes([pendingBytes, getUint8Array(chunk)]);\n      continue;\n    }\n\n    const rowBytes = pendingBytes.subarray(0, rowByteLength);\n    batchBytes.push(rowBytes);\n    batchByteLength += rowByteLength;\n    batchRowCount++;\n    remainingVertices--;\n    pendingBytes = pendingBytes.subarray(rowByteLength);\n\n    if (batchRowCount >= batchSize) {\n      yield makeBinaryPLYArrowBatchFromRows(\n        header,\n        batchBytes,\n        batchByteLength,\n        batchRowCount,\n        options\n      );\n      batchBytes = [];\n      batchByteLength = 0;\n      batchRowCount = 0;\n    }\n  }\n\n  if (batchRowCount > 0) {\n    yield makeBinaryPLYArrowBatchFromRows(\n      header,\n      batchBytes,\n      batchByteLength,\n      batchRowCount,\n      options\n    );\n  }\n}\n\n/** Read and parse the PLY header from the byte stream. */\nasync function readPLYHeader(\n  iterator: AsyncIterator<ArrayBufferLike>,\n  options: any\n): Promise<{header: PLYHeader; initialBodyBytes: ByteArray}> {\n  let headerBytes: ByteArray = new Uint8Array(0);\n\n  while (true) {\n    const {value, done} = await iterator.next();\n    if (done) {\n      throw new Error('Incomplete PLY header');\n    }\n\n    headerBytes = concatenateBytes([headerBytes, getUint8Array(value)]);\n    const headerEnd = findHeaderEnd(headerBytes);\n    if (headerEnd === -1) {\n      continue;\n    }\n\n    const header = parsePLYHeader(getArrayBuffer(headerBytes.subarray(0, headerEnd)), options);\n    return {header, initialBodyBytes: headerBytes.subarray(headerEnd)};\n  }\n}\n\n/** Return the vertex element, or throw for unsupported Arrow batches. */\nfunction getVertexElement(header: PLYHeader, options: any): PLYElement {\n  const vertexElement = header.elements[0];\n  if ((!options?.pointCloud && header.elements.length !== 1) || vertexElement?.name !== 'vertex') {\n    throw new Error('PLY arrow-table batch parsing requires one vertex element');\n  }\n  return vertexElement;\n}\n\n/** Return the fixed-width vertex element, or throw for unsupported binary batches. */\nfunction getFixedWidthVertexElement(header: PLYHeader, options: any): PLYElement {\n  const vertexElement = header.elements[0];\n  if (\n    (!options?.pointCloud && header.elements.length !== 1) ||\n    vertexElement?.name !== 'vertex' ||\n    vertexElement.properties.some(property => property.type === 'list')\n  ) {\n    throw new Error('Binary PLY arrow-table batch parsing requires one scalar vertex element');\n  }\n  return vertexElement;\n}\n\n/** Build one Arrow table batch from pending vertex record bytes. */\nfunction makeBinaryPLYArrowBatch(\n  header: PLYHeader,\n  pendingBytes: ByteArray,\n  vertexCount: number,\n  vertexStride: number,\n  options: any,\n  parsePlan: PLYBinaryPointCloudParsePlan | null\n): MeshArrowTable {\n  const vertexElement = header.elements[0];\n  const batchHeader = {\n    ...header,\n    headerLength: 0,\n    elements: [{...vertexElement, count: vertexCount}]\n  };\n  const byteLength = vertexCount * vertexStride;\n  const table = parsePLYBinaryPointCloudRecordsToArrowTable(\n    pendingBytes.subarray(0, byteLength),\n    batchHeader,\n    options,\n    parsePlan || undefined\n  );\n  if (!table) {\n    throw new Error('Failed to parse binary PLY Arrow batch');\n  }\n  return table;\n}\n\n/** Build one Arrow table batch from ASCII PLY vertex lines. */\nfunction makeASCIIPLYArrowBatch(header: PLYHeader, lines: string[], options: any): MeshArrowTable {\n  const batchHeaderText = makePLYHeaderText(header, lines.length, options);\n  const elementTables = parsePLYToElementTables(`${batchHeaderText}${lines.join('\\n')}\\n`, options);\n  return convertPLYElementTablesToMeshArrowTable(elementTables);\n}\n\n/** Build one Arrow table batch from variable-width binary PLY vertex rows. */\nfunction makeBinaryPLYArrowBatchFromRows(\n  header: PLYHeader,\n  rows: ByteArray[],\n  byteLength: number,\n  vertexCount: number,\n  options: any\n): MeshArrowTable {\n  const batchHeaderText = makePLYHeaderText(header, vertexCount, options);\n  const headerBytes = new TextEncoder().encode(batchHeaderText);\n  const batchBytes = new Uint8Array(headerBytes.length + byteLength);\n  batchBytes.set(headerBytes, 0);\n  let byteOffset = headerBytes.length;\n  for (const row of rows) {\n    batchBytes.set(row, byteOffset);\n    byteOffset += row.length;\n  }\n  const elementTables = parsePLYToElementTables(getArrayBuffer(batchBytes), options);\n  return convertPLYElementTablesToMeshArrowTable(elementTables);\n}\n\n/** Return binary element row byte length, or null if more bytes are needed. */\nfunction getBinaryElementRowByteLength(\n  bytes: ByteArray,\n  element: PLYElement,\n  littleEndian: boolean\n): number | null {\n  const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n  let byteOffset = 0;\n\n  for (const property of element.properties) {\n    if (property.type === 'list') {\n      const countSize = getPLYTypeSize(property.countType!);\n      if (byteOffset + countSize > bytes.length) {\n        return null;\n      }\n      const count = readBinaryScalar(dataView, byteOffset, property.countType!, littleEndian);\n      byteOffset += countSize;\n      const valuesByteLength = count * getPLYTypeSize(property.itemType!);\n      if (byteOffset + valuesByteLength > bytes.length) {\n        return null;\n      }\n      byteOffset += valuesByteLength;\n    } else {\n      const propertySize = getPLYTypeSize(property.type);\n      if (byteOffset + propertySize > bytes.length) {\n        return null;\n      }\n      byteOffset += propertySize;\n    }\n  }\n\n  return byteOffset;\n}\n\n/** Read one binary scalar value. */\n// eslint-disable-next-line complexity\nfunction readBinaryScalar(\n  dataView: DataView,\n  byteOffset: number,\n  type: string,\n  littleEndian: boolean\n): number {\n  switch (type) {\n    case 'int8':\n    case 'char':\n      return dataView.getInt8(byteOffset);\n    case 'uint8':\n    case 'uchar':\n      return dataView.getUint8(byteOffset);\n    case 'int16':\n    case 'short':\n      return dataView.getInt16(byteOffset, littleEndian);\n    case 'uint16':\n    case 'ushort':\n      return dataView.getUint16(byteOffset, littleEndian);\n    case 'int32':\n    case 'int':\n      return dataView.getInt32(byteOffset, littleEndian);\n    case 'uint32':\n    case 'uint':\n      return dataView.getUint32(byteOffset, littleEndian);\n    case 'float32':\n    case 'float':\n      return dataView.getFloat32(byteOffset, littleEndian);\n    case 'float64':\n    case 'double':\n      return dataView.getFloat64(byteOffset, littleEndian);\n    default:\n      throw new Error(type);\n  }\n}\n\n/** Rebuild a PLY header text for one emitted batch. */\nfunction makePLYHeaderText(header: PLYHeader, vertexCount: number, options: any): string {\n  const lines = ['ply', `format ${header.format} ${header.version || '1.0'}`];\n  const elements = options?.pointCloud ? header.elements.slice(0, 1) : header.elements;\n  for (const comment of header.comments) {\n    lines.push(`comment ${comment}`);\n  }\n  for (const element of elements) {\n    lines.push(\n      `element ${element.name} ${element.name === 'vertex' ? vertexCount : element.count}`\n    );\n    for (const property of element.properties) {\n      lines.push(\n        property.type === 'list'\n          ? `property list ${property.countType} ${property.itemType} ${property.name}`\n          : `property ${property.type} ${property.name}`\n      );\n    }\n  }\n  lines.push('end_header');\n  return `${lines.join('\\n')}\\n`;\n}\n\n/** Return a byte iterator that emits pending body bytes before reading source chunks. */\nasync function* getByteIteratorWithInitialBytes(\n  iterator: AsyncIterator<ArrayBufferLike>,\n  initialBodyBytes: ByteArray\n): AsyncIterable<ArrayBuffer> {\n  if (initialBodyBytes.length > 0) {\n    yield getArrayBuffer(initialBodyBytes);\n  }\n  while (true) {\n    const {value, done} = await iterator.next();\n    if (done) {\n      break;\n    }\n    yield getArrayBuffer(getUint8Array(value));\n  }\n}\n\n/** Return the configured binary PLY batch size. */\nfunction getBatchSize(options: any): number {\n  const batchSize = options?.batchSize;\n  return typeof batchSize === 'number' ? batchSize : DEFAULT_BINARY_BATCH_SIZE;\n}\n\n/** Return the byte size of a fixed-width PLY element. */\nfunction getPLYElementSize(element: PLYElement): number {\n  return element.properties.reduce((size, property) => size + getPLYTypeSize(property.type), 0);\n}\n\n/** Return the byte size of a scalar PLY type. */\n// eslint-disable-next-line complexity\nfunction getPLYTypeSize(type: string): number {\n  switch (type) {\n    case 'int8':\n    case 'uint8':\n    case 'char':\n    case 'uchar':\n      return 1;\n    case 'int16':\n    case 'uint16':\n    case 'short':\n    case 'ushort':\n      return 2;\n    case 'int32':\n    case 'uint32':\n    case 'int':\n    case 'uint':\n    case 'float32':\n    case 'float':\n      return 4;\n    case 'float64':\n    case 'double':\n      return 8;\n    default:\n      throw new Error(type);\n  }\n}\n\n/** Find the byte offset immediately after the `end_header` terminator. */\nfunction findHeaderEnd(bytes: Uint8Array): number {\n  const pattern = new TextEncoder().encode(PLY_END_HEADER);\n  const lastPatternStart = bytes.length - pattern.length;\n\n  for (let byteIndex = 0; byteIndex <= lastPatternStart; byteIndex++) {\n    let matches = true;\n    for (let patternIndex = 0; patternIndex < pattern.length; patternIndex++) {\n      if (bytes[byteIndex + patternIndex] !== pattern[patternIndex]) {\n        matches = false;\n        break;\n      }\n    }\n\n    if (matches) {\n      let headerEnd = byteIndex + pattern.length;\n      if (\n        headerEnd === bytes.length ||\n        (bytes[headerEnd] === 0x0d && headerEnd + 1 === bytes.length)\n      ) {\n        return -1;\n      }\n      if (bytes[headerEnd] === 0x0d && bytes[headerEnd + 1] === 0x0a) {\n        headerEnd += 2;\n      } else if (headerEnd < bytes.length && isWhitespaceByte(bytes[headerEnd])) {\n        headerEnd += 1;\n      }\n      return headerEnd;\n    }\n  }\n\n  return -1;\n}\n\n/** Return true for ASCII whitespace bytes that can terminate a PLY header. */\nfunction isWhitespaceByte(byte: number): boolean {\n  return byte === 0x0a || byte === 0x0d || byte === 0x09 || byte === 0x20;\n}\n\n/** Normalize an ArrayBuffer or view into a Uint8Array view. */\nfunction getUint8Array(data: ArrayBufferLike | ArrayBufferView): ByteArray {\n  return ArrayBuffer.isView(data)\n    ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength)\n    : new Uint8Array(data);\n}\n\n/** Return an exact ArrayBuffer copy for a byte range. */\nfunction getArrayBuffer(bytes: ByteArray): ArrayBuffer {\n  const copy = new Uint8Array(bytes.byteLength);\n  copy.set(bytes);\n  return copy.buffer;\n}\n\n/** Concatenate byte chunks into a new Uint8Array. */\nfunction concatenateBytes(chunks: ByteArray[]): ByteArray {\n  const byteLength = chunks.reduce((length, chunk) => length + chunk.length, 0);\n  const bytes = new Uint8Array(byteLength);\n  let byteOffset = 0;\n\n  for (const chunk of chunks) {\n    bytes.set(chunk, byteOffset);\n    byteOffset += chunk.length;\n  }\n\n  return bytes;\n}\n\n/**\n * Parses header\n * @param lineIterator\n * @param options\n * @returns\n */\nasync function parseASCIIHeader(\n  lineIterator: AsyncIterable<string> | Iterable<string>,\n  options: {[key: string]: any}\n): Promise<PLYHeader> {\n  let currentElement: PLYElement | undefined;\n  const header: PLYHeader = {\n    comments: [],\n    elements: []\n    // headerLength\n  };\n\n  // Note: forEach does not reset iterator if exiting loop prematurely\n  // so that iteration can continue in a second loop\n  await forEach(lineIterator, (line: string) => {\n    line = line.trim();\n\n    // End of header\n    if (line === 'end_header') {\n      return true; // Returning true cancels `forEach`\n    }\n\n    // Ignore empty lines\n    if (line === '') {\n      // eslint-disable-next-line\n      return false; // Returning false does not cancel `forEach`\n    }\n\n    const lineValues = line.split(/\\s+/);\n    const lineType = lineValues.shift();\n    line = lineValues.join(' ');\n\n    switch (lineType) {\n      case 'ply':\n        // First line magic characters, ignore\n        break;\n\n      case 'format':\n        header.format = lineValues[0];\n        header.version = lineValues[1];\n        break;\n\n      case 'comment':\n        header.comments.push(line);\n        break;\n\n      case 'element':\n        if (currentElement) {\n          header.elements.push(currentElement);\n        }\n\n        currentElement = {\n          name: lineValues[0],\n          count: parseInt(lineValues[1], 10),\n          properties: []\n        };\n        break;\n\n      case 'property':\n        const property = makePLYElementProperty(lineValues, options.propertyNameMapping);\n        currentElement?.properties.push(property);\n        break;\n\n      default:\n        // eslint-disable-next-line\n        console.log('unhandled', lineType, lineValues);\n    }\n\n    return false;\n  });\n\n  if (currentElement) {\n    header.elements.push(currentElement);\n  }\n\n  return header;\n}\n\nfunction makePLYElementProperty(propertyValues: string[], propertyNameMapping: []): PLYProperty {\n  const type = propertyValues[0];\n  switch (type) {\n    case 'list':\n      return {\n        type,\n        name: propertyValues[3],\n        countType: propertyValues[1],\n        itemType: propertyValues[2]\n      };\n    default:\n      return {\n        type,\n        name: propertyValues[1]\n      };\n  }\n}\n\n// ASCII PARSING\n/**\n * @param lineIterator\n * @param header\n * @returns\n */\nasync function parseASCII(lineIterator: AsyncIterable<string>, header: PLYHeader) {\n  // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)\n  const attributes: MutablePLYAttributes = {\n    indices: [],\n    vertices: [],\n    normals: [],\n    uvs: [],\n    colors: []\n  };\n\n  let currentElement = 0;\n  let currentElementCount = 0;\n\n  for await (let line of lineIterator) {\n    line = line.trim();\n\n    if (line !== '') {\n      if (currentElementCount >= header.elements[currentElement].count) {\n        currentElement++;\n        currentElementCount = 0;\n      }\n\n      const element = parsePLYElement(header.elements[currentElement].properties, line);\n      handleElement(attributes, header.elements[currentElement].name, element);\n      currentElementCount++;\n    }\n  }\n\n  return attributes;\n}\n/**\n * Parses ASCII number\n * @param n\n * @param type\n * @returns ASCII number\n */\n// eslint-disable-next-line complexity\nfunction parseASCIINumber(n: string, type: string): number {\n  switch (type) {\n    case 'char':\n    case 'uchar':\n    case 'short':\n    case 'ushort':\n    case 'int':\n    case 'uint':\n    case 'int8':\n    case 'uint8':\n    case 'int16':\n    case 'uint16':\n    case 'int32':\n    case 'uint32':\n      return parseInt(n, 10);\n\n    case 'float':\n    case 'double':\n    case 'float32':\n    case 'float64':\n      return parseFloat(n);\n\n    default:\n      throw new Error(type);\n  }\n}\n/**\n * Parses ASCII element\n * @param properties\n * @param line\n * @returns element\n */\nfunction parsePLYElement(properties: any[], line: string) {\n  const values: any = line.split(/\\s+/);\n\n  const element = {};\n\n  for (let i = 0; i < properties.length; i++) {\n    if (properties[i].type === 'list') {\n      const list: any = [];\n      const n = parseASCIINumber(values.shift(), properties[i].countType);\n\n      for (let j = 0; j < n; j++) {\n        list.push(parseASCIINumber(values.shift(), properties[i].itemType));\n      }\n\n      element[properties[i].name] = list;\n    } else {\n      element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);\n    }\n  }\n\n  return element;\n}\n/**\n * @param buffer\n * @param elementName\n * @param element\n */\n// HELPER FUNCTIONS\n// eslint-disable-next-line complexity\nfunction handleElement(\n  buffer: {[index: string]: number[]},\n  elementName: string,\n  element: any = {}\n) {\n  switch (elementName) {\n    case 'vertex':\n      buffer.vertices.push(element.x, element.y, element.z);\n      if ('nx' in element && 'ny' in element && 'nz' in element) {\n        buffer.normals.push(element.nx, element.ny, element.nz);\n      }\n      if ('s' in element && 't' in element) {\n        buffer.uvs.push(element.s, element.t);\n      }\n      if ('red' in element && 'green' in element && 'blue' in element) {\n        buffer.colors.push(element.red, element.green, element.blue);\n      }\n      break;\n\n    case 'face':\n      const vertexIndices = element.vertex_indices || element.vertex_index; // issue #9338\n      if (vertexIndices.length === 3) {\n        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);\n      } else if (vertexIndices.length === 4) {\n        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);\n        buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);\n      }\n      break;\n\n    default:\n      break;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["normalizePLY"]
+}

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

@@ -0,0 +1,9 @@
+import type { MeshArrowTable } from '@loaders.gl/core/schema';
+import { PLYMesh } from "./ply-types.js";
+/**
+ * PARSER
+ * @param iterator
+ * @param options
+ */
+export declare function parsePLYInBatches(iterator: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options: any): AsyncIterable<PLYMesh | MeshArrowTable>;
+//# sourceMappingURL=parse-ply-in-batches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ply-in-batches.d.ts","sourceRoot":"","sources":["../../../src/ply/lib/parse-ply-in-batches.ts"],"names":[],"mappings":"AAiCA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAE5D,OAAO,EAAC,OAAO,EAAoD,uBAAoB;AAcvF;;;;GAIG;AACH,wBAAuB,iBAAiB,CACtC,QAAQ,EACJ,aAAa,CAAC,eAAe,GAAG,eAAe,CAAC,GAChD,QAAQ,CAAC,eAAe,GAAG,eAAe,CAAC,EAC/C,OAAO,EAAE,GAAG,GACX,aAAa,CAAC,OAAO,GAAG,cAAc,CAAC,CAoBzC"}