@loaders.gl/ply 3.1.0-alpha.5 → 3.1.0-beta.5

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;
+}

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

@@ -26,3 +26,4 @@ export declare type ASCIIElement = {
     count: number;
     properties: any[];
 };
+//# sourceMappingURL=ply-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ply-types.d.ts","sourceRoot":"","sources":["../../src/lib/ply-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAC;AAE7C,oBAAY,SAAS,GAAG;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAwB;AACxB,oBAAY,OAAO,GAAG,IAAI,GAAG;IAC3B,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,SAAS,CAAC;CACvB,CAAC;AAIF,oBAAY,UAAU,GAAG;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACpE,CAAC;AAEF,oBAAY,aAAa,GAAG;IAC1B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC3B,CAAC;AAEF,oBAAY,WAAW,GAAG;IACxB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB,CAAC;AAEF,oBAAY,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,GAAG,EAAE,CAAC;CACnB,CAAC"}

package/dist/lib/ply-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ply-loader.d.ts

@@ -21,3 +21,4 @@ export declare const PLYLoader: {
     };
 };
 export declare const _typecheckPLYLoader: Loader;
+//# sourceMappingURL=ply-loader.d.ts.map

package/dist/ply-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ply-loader.d.ts","sourceRoot":"","sources":["../src/ply-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAMrD;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;CAerB,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,MAAkB,CAAC"}

package/dist/ply-loader.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckPLYLoader = exports.PLYLoader = void 0;
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+/**
+ * Worker loader for PLY - Polygon File Format (aka Stanford Triangle Format)'
+ * links: ['http://paulbourke.net/dataformats/ply/',
+ * 'https://en.wikipedia.org/wiki/PLY_(file_format)']
+ */
+exports.PLYLoader = {
+    name: 'PLY',
+    id: 'ply',
+    module: 'ply',
+    shapes: ['mesh', 'gltf', 'columnar-table'],
+    version: VERSION,
+    worker: true,
+    extensions: ['ply'],
+    mimeTypes: ['text/plain', 'application/octet-stream'],
+    text: true,
+    binary: true,
+    tests: ['ply'],
+    options: {
+        ply: {}
+    }
+};
+exports._typecheckPLYLoader = exports.PLYLoader;