@loaders.gl/ply 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/normalize-ply.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("@loaders.gl/schema");
+const get_ply_schema_1 = require("./get-ply-schema");
+/**
+ * @param header
+ * @param attributes
+ * @returns data and header
+ */
+function normalizePLY(plyHeader, plyAttributes, options) {
+    const attributes = getMeshAttributes(plyAttributes);
+    const boundingBox = (0, schema_1.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 = (0, get_ply_schema_1.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;
+}
+exports.default = normalizePLY;
+/**
+ * @param attributes
+ * @returns accessors []
+ */
+function getMeshAttributes(attributes) {
+    const accessors = {};
+    accessors.POSITION = { value: new Float32Array(attributes.vertices), size: 3 };
+    // optional attributes data
+    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) {
+        // TODO - normalized shoud be based on `uchar` flag in source data?
+        accessors.COLOR_0 = { value: new Uint8Array(attributes.colors), size: 3, normalized: true };
+    }
+    return accessors;
+}

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

@@ -0,0 +1,8 @@
+import { PLYMesh } from './ply-types';
+/**
+ * PARSER
+ * @param iterator
+ * @param options
+ */
+export default function parsePLYInBatches(iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options: any): AsyncIterable<PLYMesh>;
+//# sourceMappingURL=parse-ply-in-batches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ply-in-batches.d.ts","sourceRoot":"","sources":["../../src/lib/parse-ply-in-batches.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAC,OAAO,EAAyC,MAAM,aAAa,CAAC;AAI5E;;;;GAIG;AACH,wBAA+B,iBAAiB,CAC9C,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

@@ -0,0 +1,253 @@
+"use strict";
+// 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'
+//   }
+// });
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@loaders.gl/core");
+const normalize_ply_1 = __importDefault(require("./normalize-ply"));
+let currentElement;
+/**
+ * PARSER
+ * @param iterator
+ * @param options
+ */
+async function* parsePLYInBatches(iterator, options) {
+    const lineIterator = (0, core_1.makeLineIterator)((0, core_1.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 (0, normalize_ply_1.default)(header, attributes, options);
+}
+exports.default = parsePLYInBatches;
+/**
+ * Parses header
+ * @param lineIterator
+ * @param options
+ * @returns
+ */
+async function parsePLYHeader(lineIterator, options) {
+    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 (0, core_1.forEach)(lineIterator, (line) => {
+        line = line.trim();
+        // End of header
+        if (line === 'end_header') {
+            return true; // Returning true cancels `forEach`
+        }
+        // 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 header;
+}
+function makePLYElementProperty(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];
+    }
+    return property;
+}
+// ASCII PARSING
+/**
+ * @param lineIterator
+ * @param header
+ * @returns
+ */
+async function parseASCII(lineIterator, header) {
+    // 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 = parseASCIIElement(header.elements[currentElement].properties, line);
+            handleElement(attributes, header.elements[currentElement].name, element);
+            currentElementCount++;
+        }
+    }
+    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);
+    }
+}
+/**
+ * Parses ASCII element
+ * @param properties
+ * @param line
+ * @returns element
+ */
+function parseASCIIElement(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;
+}
+/**
+ * @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;
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { PLYMesh } from './ply-types';
+/**
+ * @param data
+ * @param options
+ * @returns
+ */
+export default function parsePLY(data: ArrayBuffer | string, options?: {}): PLYMesh;
+//# sourceMappingURL=parse-ply.d.ts.map

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

@@ -0,0 +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;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,OAAO,KAAK,GAAG,OAAO,CAclF"}

package/dist/lib/parse-ply.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const normalize_ply_1 = __importDefault(require("./normalize-ply"));
+/**
+ * @param data
+ * @param options
+ * @returns
+ */
+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 (0, normalize_ply_1.default)(header, attributes);
+}
+exports.default = parsePLY;
+/**
+ * @param data
+ * @param options
+ * @returns header
+ */
+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;
+}
+/**
+ * @param lines
+ * @param headerLength
+ * @param options
+ * @returns header
+ */
+function parseHeaderLines(lines, headerLength, options) {
+    const header = {
+        comments: [],
+        elements: [],
+        headerLength
+    };
+    let lineType;
+    let lineValues;
+    let currentElement = null;
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        line = line.trim();
+        if (line === '') {
+            // eslint-disable-next-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 (currentElement) {
+                    header.elements.push(currentElement);
+                }
+                currentElement = {
+                    name: lineValues[0],
+                    count: parseInt(lineValues[1], 10),
+                    properties: []
+                };
+                break;
+            case 'property':
+                if (!currentElement) {
+                    break;
+                }
+                currentElement.properties.push(makePLYElementProperty(lineValues, options.propertyNameMapping));
+                break;
+            default:
+                // eslint-disable-next-line
+                console.log('unhandled', lineType, lineValues);
+        }
+    }
+    if (currentElement !== undefined) {
+        header.elements.push(currentElement);
+    }
+    return header;
+}
+/**
+ * @param propertValues
+ * @param propertyNameMapping
+ * @returns property of ply element
+ */
+function makePLYElementProperty(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];
+    }
+    return property;
+}
+/**
+ * Parses ASCII number
+ * @param n
+ * @param type
+ * @returns
+ */
+// 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);
+    }
+}
+/**
+ * @param properties
+ * @param line
+ * @returns ASCII element
+ */
+function parseASCIIElement(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;
+}
+/**
+ * @param data
+ * @param header
+ * @returns [attributes]
+ */
+function parseASCII(data, header) {
+    // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
+    const attributes = {
+        indices: [],
+        vertices: [],
+        normals: [],
+        uvs: [],
+        colors: []
+    };
+    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 currentElement = 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[currentElement].count) {
+                currentElement++;
+                currentElementCount = 0;
+            }
+            const element = parseASCIIElement(header.elements[currentElement].properties, line);
+            handleElement(attributes, header.elements[currentElement].name, element);
+            currentElementCount++;
+        }
+    }
+    return attributes;
+}
+/**
+ * @param buffer
+ * @param elementName
+ * @param element
+ */
+// eslint-disable-next-line complexity
+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);
+        }
+    }
+    else if (elementName === '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]);
+        }
+    }
+}
+/**
+ * Reads binary data
+ * @param dataview
+ * @param at
+ * @param type
+ * @param littleEndian
+ * @returns [number, number]
+ */
+// eslint-disable-next-line complexity
+function binaryRead(dataview, at, type, littleEndian) {
+    switch (type) {
+        // corespondences for non-specific length types here match rply:
+        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);
+    }
+}
+/**
+ * Reads binary data
+ * @param dataview
+ * @param at
+ * @param properties
+ * @param littleEndian
+ * @returns [object, number]
+ */
+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);
+                // @ts-ignore
+                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];
+}
+/**
+ * Parses binary data
+ * @param data
+ * @param header
+ * @returns [attributes] of data
+ */
+function parseBinary(data, header) {
+    const attributes = {
+        indices: [],
+        vertices: [],
+        normals: [],
+        uvs: [],
+        colors: []
+    };
+    const littleEndian = header.format === 'binary_little_endian';
+    const body = new DataView(data, header.headerLength);
+    let result;
+    let loc = 0;
+    for (let currentElement = 0; currentElement < header.elements.length; currentElement++) {
+        const count = header.elements[currentElement].count;
+        for (let currentElementCount = 0; currentElementCount < count; currentElementCount++) {
+            result = binaryReadElement(body, loc, header.elements[currentElement].properties, littleEndian);
+            loc += result[1];
+            const element = result[0];
+            handleElement(attributes, header.elements[currentElement].name, element);
+        }
+    }
+    return attributes;
+}