@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/esm/node_modules/three/examples/jsm/exporters/PLYExporter.js

@@ -1 +1,538 @@
-import{Color as n,Vector3 as t,Matrix3 as e,ColorManagement as o,SRGBColorSpace as r}from"three";class l{parse(l,i,a={}){function f(n){l.traverse(function(t){if(!0===t.isMesh||t.isPoints){const e=t,o=e.geometry;!0===o.hasAttribute("position")&&n(e,o)}})}const p=(a=Object.assign({binary:!1,excludeAttributes:[],littleEndian:!1},a)).excludeAttributes;let u=!0,c=!1,s=!1,y=!1,d=0,h=0;l.traverse(function(n){if(!0===n.isMesh){const t=n.geometry,e=t.getAttribute("position"),o=t.getAttribute("normal"),r=t.getAttribute("uv"),l=t.getAttribute("color"),i=t.getIndex();if(void 0===e)return;d+=e.count,h+=i?i.count/3:e.count/3,void 0!==o&&(c=!0),void 0!==r&&(y=!0),void 0!==l&&(s=!0)}else if(n.isPoints){const t=n.geometry,e=t.getAttribute("position"),o=t.getAttribute("normal"),r=t.getAttribute("color");d+=e.count,void 0!==o&&(c=!0),void 0!==r&&(s=!0),u=!1}});const $=new n;if(u=u&&-1===p.indexOf("index"),c=c&&-1===p.indexOf("normal"),s=s&&-1===p.indexOf("color"),y=y&&-1===p.indexOf("uv"),u&&h!==Math.floor(h))return null;let m=`ply\nformat ${a.binary?a.littleEndian?"binary_little_endian":"binary_big_endian":"ascii"} 1.0\nelement vertex ${d}\nproperty float x\nproperty float y\nproperty float z\n`;!0===c&&(m+="property float nx\nproperty float ny\nproperty float nz\n"),!0===y&&(m+="property float s\nproperty float t\n"),!0===s&&(m+="property uchar red\nproperty uchar green\nproperty uchar blue\n"),!0===u&&(m+=`element face ${h}\nproperty list uchar int vertex_index\n`),m+="end_header\n";const v=new t,x=new e;let w=null;if(!0===a.binary){const n=(new TextEncoder).encode(m),t=d*(12+(c?12:0)+(s?3:0)+(y?8:0)),e=u?13*h:0,l=new DataView(new ArrayBuffer(n.length+t+e));new Uint8Array(l.buffer).set(n,0);let i=n.length,p=n.length+t,b=0;f(function(n,t){const e=t.getAttribute("position"),f=t.getAttribute("normal"),d=t.getAttribute("uv"),h=t.getAttribute("color"),m=t.getIndex();x.getNormalMatrix(n.matrixWorld);for(let t=0,p=e.count;t<p;t++)v.fromBufferAttribute(e,t),v.applyMatrix4(n.matrixWorld),l.setFloat32(i,v.x,a.littleEndian),i+=4,l.setFloat32(i,v.y,a.littleEndian),i+=4,l.setFloat32(i,v.z,a.littleEndian),i+=4,!0===c&&(null!=f?(v.fromBufferAttribute(f,t),v.applyMatrix3(x).normalize(),l.setFloat32(i,v.x,a.littleEndian),i+=4,l.setFloat32(i,v.y,a.littleEndian),i+=4,l.setFloat32(i,v.z,a.littleEndian),i+=4):(l.setFloat32(i,0,a.littleEndian),i+=4,l.setFloat32(i,0,a.littleEndian),i+=4,l.setFloat32(i,0,a.littleEndian),i+=4)),!0===y&&(null!=d?(l.setFloat32(i,d.getX(t),a.littleEndian),i+=4,l.setFloat32(i,d.getY(t),a.littleEndian),i+=4):(l.setFloat32(i,0,a.littleEndian),i+=4,l.setFloat32(i,0,a.littleEndian),i+=4)),!0===s&&(null!=h?($.fromBufferAttribute(h,t),o.workingToColorSpace($,r),l.setUint8(i,Math.floor(255*$.r)),i+=1,l.setUint8(i,Math.floor(255*$.g)),i+=1,l.setUint8(i,Math.floor(255*$.b)),i+=1):(l.setUint8(i,255),i+=1,l.setUint8(i,255),i+=1,l.setUint8(i,255),i+=1));if(!0===u)if(null!==m)for(let n=0,t=m.count;n<t;n+=3)l.setUint8(p,3),p+=1,l.setUint32(p,m.getX(n+0)+b,a.littleEndian),p+=4,l.setUint32(p,m.getX(n+1)+b,a.littleEndian),p+=4,l.setUint32(p,m.getX(n+2)+b,a.littleEndian),p+=4;else for(let n=0,t=e.count;n<t;n+=3)l.setUint8(p,3),p+=1,l.setUint32(p,b+n,a.littleEndian),p+=4,l.setUint32(p,b+n+1,a.littleEndian),p+=4,l.setUint32(p,b+n+2,a.littleEndian),p+=4;b+=e.count}),w=l.buffer}else{let n=0,t="",e="";f(function(l,i){const a=i.getAttribute("position"),f=i.getAttribute("normal"),p=i.getAttribute("uv"),d=i.getAttribute("color"),m=i.getIndex();x.getNormalMatrix(l.matrixWorld);for(let n=0,e=a.count;n<e;n++){v.fromBufferAttribute(a,n),v.applyMatrix4(l.matrixWorld);let e=v.x+" "+v.y+" "+v.z;!0===c&&(null!=f?(v.fromBufferAttribute(f,n),v.applyMatrix3(x).normalize(),e+=" "+v.x+" "+v.y+" "+v.z):e+=" 0 0 0"),!0===y&&(e+=null!=p?" "+p.getX(n)+" "+p.getY(n):" 0 0"),!0===s&&(null!=d?($.fromBufferAttribute(d,n),o.workingToColorSpace($,r),e+=" "+Math.floor(255*$.r)+" "+Math.floor(255*$.g)+" "+Math.floor(255*$.b)):e+=" 255 255 255"),t+=e+"\n"}if(!0===u){if(null!==m)for(let t=0,o=m.count;t<o;t+=3)e+=`3 ${m.getX(t+0)+n}`,e+=` ${m.getX(t+1)+n}`,e+=` ${m.getX(t+2)+n}\n`;else for(let t=0,o=a.count;t<o;t+=3)e+=`3 ${n+t} ${n+t+1} ${n+t+2}\n`;h+=m?m.count/3:a.count/3}n+=a.count}),w=`${m}${t}${u?`${e}\n`:"\n"}`}return"function"==typeof i&&requestAnimationFrame(()=>i(w)),w}}export{l as PLYExporter};
+import { Color, Vector3, Matrix3, ColorManagement, SRGBColorSpace } from 'three';
+
+/**
+ * An exporter for PLY.
+ *
+ * PLY (Polygon or Stanford Triangle Format) is a file format for efficient delivery and
+ * loading of simple, static 3D content in a dense format. Both binary and ascii formats are
+ * supported. PLY can store vertex positions, colors, normals and uv coordinates. No textures
+ * or texture references are saved.
+ *
+ * ```js
+ * const exporter = new PLYExporter();
+ * const data = exporter.parse( scene, options );
+ * ```
+ *
+ * @three_import import { PLYExporter } from 'three/addons/exporters/PLYExporter.js';
+ */
+class PLYExporter {
+
+	/**
+	 * Parses the given 3D object and generates the PLY output.
+	 *
+	 * If the 3D object is composed of multiple children and geometry, they are merged into a single mesh in the file.
+	 *
+	 * @param {Object3D} object - The 3D object to export.
+	 * @param {PLYExporter~OnDone} onDone - A callback function that is executed when the export has finished.
+	 * @param {PLYExporter~Options} options - The export options.
+	 * @return {?string|ArrayBuffer} The exported PLY.
+	 */
+	parse( object, onDone, options = {} ) {
+
+		// reference https://github.com/gkjohnson/ply-exporter-js
+
+		// Iterate over the valid meshes in the object
+		function traverseMeshes( cb ) {
+
+			object.traverse( function ( child ) {
+
+				if ( child.isMesh === true || child.isPoints ) {
+
+					const mesh = child;
+					const geometry = mesh.geometry;
+
+					if ( geometry.hasAttribute( 'position' ) === true ) {
+
+						cb( mesh, geometry );
+
+					}
+
+				}
+
+			} );
+
+		}
+
+		// Default options
+		const defaultOptions = {
+			binary: false,
+			excludeAttributes: [], // normal, uv, color, index
+			littleEndian: false
+		};
+
+		options = Object.assign( defaultOptions, options );
+
+		const excludeAttributes = options.excludeAttributes;
+		let includeIndices = true;
+		let includeNormals = false;
+		let includeColors = false;
+		let includeUVs = false;
+
+		// count the vertices, check which properties are used,
+		// and cache the BufferGeometry
+		let vertexCount = 0;
+		let faceCount = 0;
+
+		object.traverse( function ( child ) {
+
+			if ( child.isMesh === true ) {
+
+				const mesh = child;
+				const geometry = mesh.geometry;
+
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const uvs = geometry.getAttribute( 'uv' );
+				const colors = geometry.getAttribute( 'color' );
+				const indices = geometry.getIndex();
+
+				if ( vertices === undefined ) {
+
+					return;
+
+				}
+
+				vertexCount += vertices.count;
+				faceCount += indices ? indices.count / 3 : vertices.count / 3;
+
+				if ( normals !== undefined ) includeNormals = true;
+
+				if ( uvs !== undefined ) includeUVs = true;
+
+				if ( colors !== undefined ) includeColors = true;
+
+			} else if ( child.isPoints ) {
+
+				const mesh = child;
+				const geometry = mesh.geometry;
+
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const colors = geometry.getAttribute( 'color' );
+
+				vertexCount += vertices.count;
+
+				if ( normals !== undefined ) includeNormals = true;
+
+				if ( colors !== undefined ) includeColors = true;
+
+				includeIndices = false;
+
+			}
+
+		} );
+
+		const tempColor = new Color();
+		includeIndices = includeIndices && excludeAttributes.indexOf( 'index' ) === - 1;
+		includeNormals = includeNormals && excludeAttributes.indexOf( 'normal' ) === - 1;
+		includeColors = includeColors && excludeAttributes.indexOf( 'color' ) === - 1;
+		includeUVs = includeUVs && excludeAttributes.indexOf( 'uv' ) === - 1;
+
+
+		if ( includeIndices && faceCount !== Math.floor( faceCount ) ) {
+
+			// point cloud meshes will not have an index array and may not have a
+			// number of vertices that is divisible by 3 (and therefore representable
+			// as triangles)
+			console.error(
+
+				'PLYExporter: Failed to generate a valid PLY file with triangle indices because the ' +
+				'number of indices is not divisible by 3.'
+
+			);
+
+			return null;
+
+		}
+
+		const indexByteCount = 4;
+
+		let header =
+			'ply\n' +
+			`format ${ options.binary ? ( options.littleEndian ? 'binary_little_endian' : 'binary_big_endian' ) : 'ascii' } 1.0\n` +
+			`element vertex ${vertexCount}\n` +
+
+			// position
+			'property float x\n' +
+			'property float y\n' +
+			'property float z\n';
+
+		if ( includeNormals === true ) {
+
+			// normal
+			header +=
+				'property float nx\n' +
+				'property float ny\n' +
+				'property float nz\n';
+
+		}
+
+		if ( includeUVs === true ) {
+
+			// uvs
+			header +=
+				'property float s\n' +
+				'property float t\n';
+
+		}
+
+		if ( includeColors === true ) {
+
+			// colors
+			header +=
+				'property uchar red\n' +
+				'property uchar green\n' +
+				'property uchar blue\n';
+
+		}
+
+		if ( includeIndices === true ) {
+
+			// faces
+			header +=
+				`element face ${faceCount}\n` +
+				'property list uchar int vertex_index\n';
+
+		}
+
+		header += 'end_header\n';
+
+
+		// Generate attribute data
+		const vertex = new Vector3();
+		const normalMatrixWorld = new Matrix3();
+		let result = null;
+
+		if ( options.binary === true ) {
+
+			// Binary File Generation
+			const headerBin = new TextEncoder().encode( header );
+
+			// 3 position values at 4 bytes
+			// 3 normal values at 4 bytes
+			// 3 color channels with 1 byte
+			// 2 uv values at 4 bytes
+			const vertexListLength = vertexCount * ( 4 * 3 + ( includeNormals ? 4 * 3 : 0 ) + ( includeColors ? 3 : 0 ) + ( includeUVs ? 4 * 2 : 0 ) );
+
+			// 1 byte shape descriptor
+			// 3 vertex indices at ${indexByteCount} bytes
+			const faceListLength = includeIndices ? faceCount * ( indexByteCount * 3 + 1 ) : 0;
+			const output = new DataView( new ArrayBuffer( headerBin.length + vertexListLength + faceListLength ) );
+			new Uint8Array( output.buffer ).set( headerBin, 0 );
+
+
+			let vOffset = headerBin.length;
+			let fOffset = headerBin.length + vertexListLength;
+			let writtenVertices = 0;
+			traverseMeshes( function ( mesh, geometry ) {
+
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const uvs = geometry.getAttribute( 'uv' );
+				const colors = geometry.getAttribute( 'color' );
+				const indices = geometry.getIndex();
+
+				normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
+
+				for ( let i = 0, l = vertices.count; i < l; i ++ ) {
+
+					vertex.fromBufferAttribute( vertices, i );
+
+					vertex.applyMatrix4( mesh.matrixWorld );
+
+
+					// Position information
+					output.setFloat32( vOffset, vertex.x, options.littleEndian );
+					vOffset += 4;
+
+					output.setFloat32( vOffset, vertex.y, options.littleEndian );
+					vOffset += 4;
+
+					output.setFloat32( vOffset, vertex.z, options.littleEndian );
+					vOffset += 4;
+
+					// Normal information
+					if ( includeNormals === true ) {
+
+						if ( normals != null ) {
+
+							vertex.fromBufferAttribute( normals, i );
+
+							vertex.applyMatrix3( normalMatrixWorld ).normalize();
+
+							output.setFloat32( vOffset, vertex.x, options.littleEndian );
+							vOffset += 4;
+
+							output.setFloat32( vOffset, vertex.y, options.littleEndian );
+							vOffset += 4;
+
+							output.setFloat32( vOffset, vertex.z, options.littleEndian );
+							vOffset += 4;
+
+						} else {
+
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+
+						}
+
+					}
+
+					// UV information
+					if ( includeUVs === true ) {
+
+						if ( uvs != null ) {
+
+							output.setFloat32( vOffset, uvs.getX( i ), options.littleEndian );
+							vOffset += 4;
+
+							output.setFloat32( vOffset, uvs.getY( i ), options.littleEndian );
+							vOffset += 4;
+
+						} else {
+
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+
+							output.setFloat32( vOffset, 0, options.littleEndian );
+							vOffset += 4;
+
+						}
+
+					}
+
+					// Color information
+					if ( includeColors === true ) {
+
+						if ( colors != null ) {
+
+							tempColor.fromBufferAttribute( colors, i );
+
+							ColorManagement.workingToColorSpace( tempColor, SRGBColorSpace );
+
+							output.setUint8( vOffset, Math.floor( tempColor.r * 255 ) );
+							vOffset += 1;
+
+							output.setUint8( vOffset, Math.floor( tempColor.g * 255 ) );
+							vOffset += 1;
+
+							output.setUint8( vOffset, Math.floor( tempColor.b * 255 ) );
+							vOffset += 1;
+
+						} else {
+
+							output.setUint8( vOffset, 255 );
+							vOffset += 1;
+
+							output.setUint8( vOffset, 255 );
+							vOffset += 1;
+
+							output.setUint8( vOffset, 255 );
+							vOffset += 1;
+
+						}
+
+					}
+
+				}
+
+				if ( includeIndices === true ) {
+
+					// Create the face list
+
+					if ( indices !== null ) {
+
+						for ( let i = 0, l = indices.count; i < l; i += 3 ) {
+
+							output.setUint8( fOffset, 3 );
+							fOffset += 1;
+
+							output.setUint32( fOffset, indices.getX( i + 0 ) + writtenVertices, options.littleEndian );
+							fOffset += indexByteCount;
+
+							output.setUint32( fOffset, indices.getX( i + 1 ) + writtenVertices, options.littleEndian );
+							fOffset += indexByteCount;
+
+							output.setUint32( fOffset, indices.getX( i + 2 ) + writtenVertices, options.littleEndian );
+							fOffset += indexByteCount;
+
+						}
+
+					} else {
+
+						for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
+
+							output.setUint8( fOffset, 3 );
+							fOffset += 1;
+
+							output.setUint32( fOffset, writtenVertices + i, options.littleEndian );
+							fOffset += indexByteCount;
+
+							output.setUint32( fOffset, writtenVertices + i + 1, options.littleEndian );
+							fOffset += indexByteCount;
+
+							output.setUint32( fOffset, writtenVertices + i + 2, options.littleEndian );
+							fOffset += indexByteCount;
+
+						}
+
+					}
+
+				}
+
+
+				// Save the amount of verts we've already written so we can offset
+				// the face index on the next mesh
+				writtenVertices += vertices.count;
+
+			} );
+
+			result = output.buffer;
+
+		} else {
+
+			// Ascii File Generation
+			// count the number of vertices
+			let writtenVertices = 0;
+			let vertexList = '';
+			let faceList = '';
+
+			traverseMeshes( function ( mesh, geometry ) {
+
+				const vertices = geometry.getAttribute( 'position' );
+				const normals = geometry.getAttribute( 'normal' );
+				const uvs = geometry.getAttribute( 'uv' );
+				const colors = geometry.getAttribute( 'color' );
+				const indices = geometry.getIndex();
+
+				normalMatrixWorld.getNormalMatrix( mesh.matrixWorld );
+
+				// form each line
+				for ( let i = 0, l = vertices.count; i < l; i ++ ) {
+
+					vertex.fromBufferAttribute( vertices, i );
+
+					vertex.applyMatrix4( mesh.matrixWorld );
+
+
+					// Position information
+					let line =
+						vertex.x + ' ' +
+						vertex.y + ' ' +
+						vertex.z;
+
+					// Normal information
+					if ( includeNormals === true ) {
+
+						if ( normals != null ) {
+
+							vertex.fromBufferAttribute( normals, i );
+
+							vertex.applyMatrix3( normalMatrixWorld ).normalize();
+
+							line += ' ' +
+								vertex.x + ' ' +
+								vertex.y + ' ' +
+								vertex.z;
+
+						} else {
+
+							line += ' 0 0 0';
+
+						}
+
+					}
+
+					// UV information
+					if ( includeUVs === true ) {
+
+						if ( uvs != null ) {
+
+							line += ' ' +
+								uvs.getX( i ) + ' ' +
+								uvs.getY( i );
+
+						} else {
+
+							line += ' 0 0';
+
+						}
+
+					}
+
+					// Color information
+					if ( includeColors === true ) {
+
+						if ( colors != null ) {
+
+							tempColor.fromBufferAttribute( colors, i );
+
+							ColorManagement.workingToColorSpace( tempColor, SRGBColorSpace );
+
+							line += ' ' +
+								Math.floor( tempColor.r * 255 ) + ' ' +
+								Math.floor( tempColor.g * 255 ) + ' ' +
+								Math.floor( tempColor.b * 255 );
+
+						} else {
+
+							line += ' 255 255 255';
+
+						}
+
+					}
+
+					vertexList += line + '\n';
+
+				}
+
+				// Create the face list
+				if ( includeIndices === true ) {
+
+					if ( indices !== null ) {
+
+						for ( let i = 0, l = indices.count; i < l; i += 3 ) {
+
+							faceList += `3 ${ indices.getX( i + 0 ) + writtenVertices }`;
+							faceList += ` ${ indices.getX( i + 1 ) + writtenVertices }`;
+							faceList += ` ${ indices.getX( i + 2 ) + writtenVertices }\n`;
+
+						}
+
+					} else {
+
+						for ( let i = 0, l = vertices.count; i < l; i += 3 ) {
+
+							faceList += `3 ${ writtenVertices + i } ${ writtenVertices + i + 1 } ${ writtenVertices + i + 2 }\n`;
+
+						}
+
+					}
+
+					faceCount += indices ? indices.count / 3 : vertices.count / 3;
+
+				}
+
+				writtenVertices += vertices.count;
+
+			} );
+
+			result = `${ header }${vertexList}${ includeIndices ? `${faceList}\n` : '\n' }`;
+
+		}
+
+		if ( typeof onDone === 'function' ) requestAnimationFrame( () => onDone( result ) );
+
+		return result;
+
+	}
+
+}
+
+export { PLYExporter };