@anov/3d 0.0.1 → 0.0.2

package/examples/jsm/loaders/VTKLoader.js

@@ -0,0 +1,1163 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	Color,
+	FileLoader,
+	Float32BufferAttribute,
+	Loader
+} from 'three';
+import * as fflate from '../libs/fflate.module.js';
+
+class VTKLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setRequestHeader( scope.requestHeader );
+		loader.setWithCredentials( scope.withCredentials );
+		loader.load( url, function ( text ) {
+
+			try {
+
+				onLoad( scope.parse( text ) );
+
+			} catch ( e ) {
+
+				if ( onError ) {
+
+					onError( e );
+
+				} else {
+
+					console.error( e );
+
+				}
+
+				scope.manager.itemError( url );
+
+			}
+
+		}, onProgress, onError );
+
+	}
+
+	parse( data ) {
+
+		function parseASCII( data ) {
+
+			// connectivity of the triangles
+			const indices = [];
+
+			// triangles vertices
+			const positions = [];
+
+			// red, green, blue colors in the range 0 to 1
+			const colors = [];
+
+			// normal vector, one per vertex
+			const normals = [];
+
+			let result;
+
+			// pattern for detecting the end of a number sequence
+			const patWord = /^[^\d.\s-]+/;
+
+			// pattern for reading vertices, 3 floats or integers
+			const pat3Floats = /(\-?\d+\.?[\d\-\+e]*)\s+(\-?\d+\.?[\d\-\+e]*)\s+(\-?\d+\.?[\d\-\+e]*)/g;
+
+			// pattern for connectivity, an integer followed by any number of ints
+			// the first integer is the number of polygon nodes
+			const patConnectivity = /^(\d+)\s+([\s\d]*)/;
+
+			// indicates start of vertex data section
+			const patPOINTS = /^POINTS /;
+
+			// indicates start of polygon connectivity section
+			const patPOLYGONS = /^POLYGONS /;
+
+			// indicates start of triangle strips section
+			const patTRIANGLE_STRIPS = /^TRIANGLE_STRIPS /;
+
+			// POINT_DATA number_of_values
+			const patPOINT_DATA = /^POINT_DATA[ ]+(\d+)/;
+
+			// CELL_DATA number_of_polys
+			const patCELL_DATA = /^CELL_DATA[ ]+(\d+)/;
+
+			// Start of color section
+			const patCOLOR_SCALARS = /^COLOR_SCALARS[ ]+(\w+)[ ]+3/;
+
+			// NORMALS Normals float
+			const patNORMALS = /^NORMALS[ ]+(\w+)[ ]+(\w+)/;
+
+			let inPointsSection = false;
+			let inPolygonsSection = false;
+			let inTriangleStripSection = false;
+			let inPointDataSection = false;
+			let inCellDataSection = false;
+			let inColorSection = false;
+			let inNormalsSection = false;
+
+			const color = new Color();
+
+			const lines = data.split( '\n' );
+
+			for ( const i in lines ) {
+
+				const line = lines[ i ].trim();
+
+				if ( line.indexOf( 'DATASET' ) === 0 ) {
+
+					const dataset = line.split( ' ' )[ 1 ];
+
+					if ( dataset !== 'POLYDATA' ) throw new Error( 'Unsupported DATASET type: ' + dataset );
+
+				} else if ( inPointsSection ) {
+
+					// get the vertices
+					while ( ( result = pat3Floats.exec( line ) ) !== null ) {
+
+						if ( patWord.exec( line ) !== null ) break;
+
+						const x = parseFloat( result[ 1 ] );
+						const y = parseFloat( result[ 2 ] );
+						const z = parseFloat( result[ 3 ] );
+						positions.push( x, y, z );
+
+					}
+
+				} else if ( inPolygonsSection ) {
+
+					if ( ( result = patConnectivity.exec( line ) ) !== null ) {
+
+						// numVertices i0 i1 i2 ...
+						const numVertices = parseInt( result[ 1 ] );
+						const inds = result[ 2 ].split( /\s+/ );
+
+						if ( numVertices >= 3 ) {
+
+							const i0 = parseInt( inds[ 0 ] );
+							let k = 1;
+							// split the polygon in numVertices - 2 triangles
+							for ( let j = 0; j < numVertices - 2; ++ j ) {
+
+								const i1 = parseInt( inds[ k ] );
+								const i2 = parseInt( inds[ k + 1 ] );
+								indices.push( i0, i1, i2 );
+								k ++;
+
+							}
+
+						}
+
+					}
+
+				} else if ( inTriangleStripSection ) {
+
+					if ( ( result = patConnectivity.exec( line ) ) !== null ) {
+
+						// numVertices i0 i1 i2 ...
+						const numVertices = parseInt( result[ 1 ] );
+						const inds = result[ 2 ].split( /\s+/ );
+
+						if ( numVertices >= 3 ) {
+
+							// split the polygon in numVertices - 2 triangles
+							for ( let j = 0; j < numVertices - 2; j ++ ) {
+
+								if ( j % 2 === 1 ) {
+
+									const i0 = parseInt( inds[ j ] );
+									const i1 = parseInt( inds[ j + 2 ] );
+									const i2 = parseInt( inds[ j + 1 ] );
+									indices.push( i0, i1, i2 );
+
+								} else {
+
+									const i0 = parseInt( inds[ j ] );
+									const i1 = parseInt( inds[ j + 1 ] );
+									const i2 = parseInt( inds[ j + 2 ] );
+									indices.push( i0, i1, i2 );
+
+								}
+
+							}
+
+						}
+
+					}
+
+				} else if ( inPointDataSection || inCellDataSection ) {
+
+					if ( inColorSection ) {
+
+						// Get the colors
+
+						while ( ( result = pat3Floats.exec( line ) ) !== null ) {
+
+							if ( patWord.exec( line ) !== null ) break;
+
+							const r = parseFloat( result[ 1 ] );
+							const g = parseFloat( result[ 2 ] );
+							const b = parseFloat( result[ 3 ] );
+
+							color.set( r, g, b ).convertSRGBToLinear();
+
+							colors.push( color.r, color.g, color.b );
+
+						}
+
+					} else if ( inNormalsSection ) {
+
+						// Get the normal vectors
+
+						while ( ( result = pat3Floats.exec( line ) ) !== null ) {
+
+							if ( patWord.exec( line ) !== null ) break;
+
+							const nx = parseFloat( result[ 1 ] );
+							const ny = parseFloat( result[ 2 ] );
+							const nz = parseFloat( result[ 3 ] );
+							normals.push( nx, ny, nz );
+
+						}
+
+					}
+
+				}
+
+				if ( patPOLYGONS.exec( line ) !== null ) {
+
+					inPolygonsSection = true;
+					inPointsSection = false;
+					inTriangleStripSection = false;
+
+				} else if ( patPOINTS.exec( line ) !== null ) {
+
+					inPolygonsSection = false;
+					inPointsSection = true;
+					inTriangleStripSection = false;
+
+				} else if ( patTRIANGLE_STRIPS.exec( line ) !== null ) {
+
+					inPolygonsSection = false;
+					inPointsSection = false;
+					inTriangleStripSection = true;
+
+				} else if ( patPOINT_DATA.exec( line ) !== null ) {
+
+					inPointDataSection = true;
+					inPointsSection = false;
+					inPolygonsSection = false;
+					inTriangleStripSection = false;
+
+				} else if ( patCELL_DATA.exec( line ) !== null ) {
+
+					inCellDataSection = true;
+					inPointsSection = false;
+					inPolygonsSection = false;
+					inTriangleStripSection = false;
+
+				} else if ( patCOLOR_SCALARS.exec( line ) !== null ) {
+
+					inColorSection = true;
+					inNormalsSection = false;
+					inPointsSection = false;
+					inPolygonsSection = false;
+					inTriangleStripSection = false;
+
+				} else if ( patNORMALS.exec( line ) !== null ) {
+
+					inNormalsSection = true;
+					inColorSection = false;
+					inPointsSection = false;
+					inPolygonsSection = false;
+					inTriangleStripSection = false;
+
+				}
+
+			}
+
+			let geometry = new BufferGeometry();
+			geometry.setIndex( indices );
+			geometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+
+			if ( normals.length === positions.length ) {
+
+				geometry.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+
+			}
+
+			if ( colors.length !== indices.length ) {
+
+				// stagger
+
+				if ( colors.length === positions.length ) {
+
+					geometry.setAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );
+
+				}
+
+			} else {
+
+				// cell
+
+				geometry = geometry.toNonIndexed();
+				const numTriangles = geometry.attributes.position.count / 3;
+
+				if ( colors.length === ( numTriangles * 3 ) ) {
+
+					const newColors = [];
+
+					for ( let i = 0; i < numTriangles; i ++ ) {
+
+						const r = colors[ 3 * i + 0 ];
+						const g = colors[ 3 * i + 1 ];
+						const b = colors[ 3 * i + 2 ];
+
+						color.set( r, g, b ).convertSRGBToLinear();
+
+						newColors.push( color.r, color.g, color.b );
+						newColors.push( color.r, color.g, color.b );
+						newColors.push( color.r, color.g, color.b );
+
+					}
+
+					geometry.setAttribute( 'color', new Float32BufferAttribute( newColors, 3 ) );
+
+				}
+
+			}
+
+			return geometry;
+
+		}
+
+		function parseBinary( data ) {
+
+			const buffer = new Uint8Array( data );
+			const dataView = new DataView( data );
+
+			// Points and normals, by default, are empty
+			let points = [];
+			let normals = [];
+			let indices = [];
+
+			let index = 0;
+
+			function findString( buffer, start ) {
+
+				let index = start;
+				let c = buffer[ index ];
+				const s = [];
+				while ( c !== 10 ) {
+
+					s.push( String.fromCharCode( c ) );
+					index ++;
+					c = buffer[ index ];
+
+				}
+
+				return { start: start,
+					end: index,
+					next: index + 1,
+					parsedString: s.join( '' ) };
+
+			}
+
+			let state, line;
+
+			while ( true ) {
+
+				// Get a string
+				state = findString( buffer, index );
+				line = state.parsedString;
+
+				if ( line.indexOf( 'DATASET' ) === 0 ) {
+
+					const dataset = line.split( ' ' )[ 1 ];
+
+					if ( dataset !== 'POLYDATA' ) throw new Error( 'Unsupported DATASET type: ' + dataset );
+
+				} else if ( line.indexOf( 'POINTS' ) === 0 ) {
+
+					// Add the points
+					const numberOfPoints = parseInt( line.split( ' ' )[ 1 ], 10 );
+
+					// Each point is 3 4-byte floats
+					const count = numberOfPoints * 4 * 3;
+
+					points = new Float32Array( numberOfPoints * 3 );
+
+					let pointIndex = state.next;
+					for ( let i = 0; i < numberOfPoints; i ++ ) {
+
+						points[ 3 * i ] = dataView.getFloat32( pointIndex, false );
+						points[ 3 * i + 1 ] = dataView.getFloat32( pointIndex + 4, false );
+						points[ 3 * i + 2 ] = dataView.getFloat32( pointIndex + 8, false );
+						pointIndex = pointIndex + 12;
+
+					}
+
+					// increment our next pointer
+					state.next = state.next + count + 1;
+
+				} else if ( line.indexOf( 'TRIANGLE_STRIPS' ) === 0 ) {
+
+					const numberOfStrips = parseInt( line.split( ' ' )[ 1 ], 10 );
+					const size = parseInt( line.split( ' ' )[ 2 ], 10 );
+					// 4 byte integers
+					const count = size * 4;
+
+					indices = new Uint32Array( 3 * size - 9 * numberOfStrips );
+					let indicesIndex = 0;
+
+					let pointIndex = state.next;
+					for ( let i = 0; i < numberOfStrips; i ++ ) {
+
+						// For each strip, read the first value, then record that many more points
+						const indexCount = dataView.getInt32( pointIndex, false );
+						const strip = [];
+						pointIndex += 4;
+						for ( let s = 0; s < indexCount; s ++ ) {
+
+							strip.push( dataView.getInt32( pointIndex, false ) );
+							pointIndex += 4;
+
+						}
+
+						// retrieves the n-2 triangles from the triangle strip
+						for ( let j = 0; j < indexCount - 2; j ++ ) {
+
+							if ( j % 2 ) {
+
+								indices[ indicesIndex ++ ] = strip[ j ];
+								indices[ indicesIndex ++ ] = strip[ j + 2 ];
+								indices[ indicesIndex ++ ] = strip[ j + 1 ];
+
+							} else {
+
+
+								indices[ indicesIndex ++ ] = strip[ j ];
+								indices[ indicesIndex ++ ] = strip[ j + 1 ];
+								indices[ indicesIndex ++ ] = strip[ j + 2 ];
+
+							}
+
+						}
+
+					}
+
+					// increment our next pointer
+					state.next = state.next + count + 1;
+
+				} else if ( line.indexOf( 'POLYGONS' ) === 0 ) {
+
+					const numberOfStrips = parseInt( line.split( ' ' )[ 1 ], 10 );
+					const size = parseInt( line.split( ' ' )[ 2 ], 10 );
+					// 4 byte integers
+					const count = size * 4;
+
+					indices = new Uint32Array( 3 * size - 9 * numberOfStrips );
+					let indicesIndex = 0;
+
+					let pointIndex = state.next;
+					for ( let i = 0; i < numberOfStrips; i ++ ) {
+
+						// For each strip, read the first value, then record that many more points
+						const indexCount = dataView.getInt32( pointIndex, false );
+						const strip = [];
+						pointIndex += 4;
+						for ( let s = 0; s < indexCount; s ++ ) {
+
+							strip.push( dataView.getInt32( pointIndex, false ) );
+							pointIndex += 4;
+
+						}
+
+						// divide the polygon in n-2 triangle
+						for ( let j = 1; j < indexCount - 1; j ++ ) {
+
+							indices[ indicesIndex ++ ] = strip[ 0 ];
+							indices[ indicesIndex ++ ] = strip[ j ];
+							indices[ indicesIndex ++ ] = strip[ j + 1 ];
+
+						}
+
+					}
+
+					// increment our next pointer
+					state.next = state.next + count + 1;
+
+				} else if ( line.indexOf( 'POINT_DATA' ) === 0 ) {
+
+					const numberOfPoints = parseInt( line.split( ' ' )[ 1 ], 10 );
+
+					// Grab the next line
+					state = findString( buffer, state.next );
+
+					// Now grab the binary data
+					const count = numberOfPoints * 4 * 3;
+
+					normals = new Float32Array( numberOfPoints * 3 );
+					let pointIndex = state.next;
+					for ( let i = 0; i < numberOfPoints; i ++ ) {
+
+						normals[ 3 * i ] = dataView.getFloat32( pointIndex, false );
+						normals[ 3 * i + 1 ] = dataView.getFloat32( pointIndex + 4, false );
+						normals[ 3 * i + 2 ] = dataView.getFloat32( pointIndex + 8, false );
+						pointIndex += 12;
+
+					}
+
+					// Increment past our data
+					state.next = state.next + count;
+
+				}
+
+				// Increment index
+				index = state.next;
+
+				if ( index >= buffer.byteLength ) {
+
+					break;
+
+				}
+
+			}
+
+			const geometry = new BufferGeometry();
+			geometry.setIndex( new BufferAttribute( indices, 1 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( points, 3 ) );
+
+			if ( normals.length === points.length ) {
+
+				geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+
+			}
+
+			return geometry;
+
+		}
+
+		function Float32Concat( first, second ) {
+
+			const firstLength = first.length, result = new Float32Array( firstLength + second.length );
+
+			result.set( first );
+			result.set( second, firstLength );
+
+			return result;
+
+		}
+
+		function Int32Concat( first, second ) {
+
+			const firstLength = first.length, result = new Int32Array( firstLength + second.length );
+
+			result.set( first );
+			result.set( second, firstLength );
+
+			return result;
+
+		}
+
+		function parseXML( stringFile ) {
+
+			// Changes XML to JSON, based on https://davidwalsh.name/convert-xml-json
+
+			function xmlToJson( xml ) {
+
+				// Create the return object
+				let obj = {};
+
+				if ( xml.nodeType === 1 ) { // element
+
+					// do attributes
+
+					if ( xml.attributes ) {
+
+						if ( xml.attributes.length > 0 ) {
+
+							obj[ 'attributes' ] = {};
+
+							for ( let j = 0; j < xml.attributes.length; j ++ ) {
+
+								const attribute = xml.attributes.item( j );
+								obj[ 'attributes' ][ attribute.nodeName ] = attribute.nodeValue.trim();
+
+							}
+
+						}
+
+					}
+
+				} else if ( xml.nodeType === 3 ) { // text
+
+					obj = xml.nodeValue.trim();
+
+				}
+
+				// do children
+				if ( xml.hasChildNodes() ) {
+
+					for ( let i = 0; i < xml.childNodes.length; i ++ ) {
+
+						const item = xml.childNodes.item( i );
+						const nodeName = item.nodeName;
+
+						if ( typeof obj[ nodeName ] === 'undefined' ) {
+
+							const tmp = xmlToJson( item );
+
+							if ( tmp !== '' ) obj[ nodeName ] = tmp;
+
+						} else {
+
+							if ( typeof obj[ nodeName ].push === 'undefined' ) {
+
+								const old = obj[ nodeName ];
+								obj[ nodeName ] = [ old ];
+
+							}
+
+							const tmp = xmlToJson( item );
+
+							if ( tmp !== '' ) obj[ nodeName ].push( tmp );
+
+						}
+
+					}
+
+				}
+
+				return obj;
+
+			}
+
+			// Taken from Base64-js
+			function Base64toByteArray( b64 ) {
+
+				const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+				const revLookup = [];
+				const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+				for ( let i = 0, l = code.length; i < l; ++ i ) {
+
+					revLookup[ code.charCodeAt( i ) ] = i;
+
+				}
+
+				revLookup[ '-'.charCodeAt( 0 ) ] = 62;
+				revLookup[ '_'.charCodeAt( 0 ) ] = 63;
+
+				const len = b64.length;
+
+				if ( len % 4 > 0 ) {
+
+					throw new Error( 'Invalid string. Length must be a multiple of 4' );
+
+				}
+
+				const placeHolders = b64[ len - 2 ] === '=' ? 2 : b64[ len - 1 ] === '=' ? 1 : 0;
+				const arr = new Arr( len * 3 / 4 - placeHolders );
+				const l = placeHolders > 0 ? len - 4 : len;
+
+				let L = 0;
+				let i, j;
+
+				for ( i = 0, j = 0; i < l; i += 4, j += 3 ) {
+
+					const tmp = ( revLookup[ b64.charCodeAt( i ) ] << 18 ) | ( revLookup[ b64.charCodeAt( i + 1 ) ] << 12 ) | ( revLookup[ b64.charCodeAt( i + 2 ) ] << 6 ) | revLookup[ b64.charCodeAt( i + 3 ) ];
+					arr[ L ++ ] = ( tmp & 0xFF0000 ) >> 16;
+					arr[ L ++ ] = ( tmp & 0xFF00 ) >> 8;
+					arr[ L ++ ] = tmp & 0xFF;
+
+				}
+
+				if ( placeHolders === 2 ) {
+
+					const tmp = ( revLookup[ b64.charCodeAt( i ) ] << 2 ) | ( revLookup[ b64.charCodeAt( i + 1 ) ] >> 4 );
+					arr[ L ++ ] = tmp & 0xFF;
+
+				} else if ( placeHolders === 1 ) {
+
+					const tmp = ( revLookup[ b64.charCodeAt( i ) ] << 10 ) | ( revLookup[ b64.charCodeAt( i + 1 ) ] << 4 ) | ( revLookup[ b64.charCodeAt( i + 2 ) ] >> 2 );
+					arr[ L ++ ] = ( tmp >> 8 ) & 0xFF;
+					arr[ L ++ ] = tmp & 0xFF;
+
+				}
+
+				return arr;
+
+			}
+
+			function parseDataArray( ele, compressed ) {
+
+				let numBytes = 0;
+
+				if ( json.attributes.header_type === 'UInt64' ) {
+
+					numBytes = 8;
+
+				}	else if ( json.attributes.header_type === 'UInt32' ) {
+
+					numBytes = 4;
+
+				}
+
+				let txt, content;
+
+				// Check the format
+				if ( ele.attributes.format === 'binary' && compressed ) {
+
+					if ( ele.attributes.type === 'Float32' ) {
+
+						txt = new Float32Array( );
+
+					} else if ( ele.attributes.type === 'Int32' || ele.attributes.type === 'Int64' ) {
+
+						txt = new Int32Array( );
+
+					}
+
+					// VTP data with the header has the following structure:
+					// [#blocks][#u-size][#p-size][#c-size-1][#c-size-2]...[#c-size-#blocks][DATA]
+					//
+					// Each token is an integer value whose type is specified by "header_type" at the top of the file (UInt32 if no type specified). The token meanings are:
+					// [#blocks] = Number of blocks
+					// [#u-size] = Block size before compression
+					// [#p-size] = Size of last partial block (zero if it not needed)
+					// [#c-size-i] = Size in bytes of block i after compression
+					//
+					// The [DATA] portion stores contiguously every block appended together. The offset from the beginning of the data section to the beginning of a block is
+					// computed by summing the compressed block sizes from preceding blocks according to the header.
+
+					const textNode = ele[ '#text' ];
+					const rawData = Array.isArray( textNode ) ? textNode[ 0 ] : textNode;
+
+					const byteData = Base64toByteArray( rawData );
+
+					// Each data point consists of 8 bits regardless of the header type
+					const dataPointSize = 8;
+
+					let blocks = byteData[ 0 ];
+					for ( let i = 1; i < numBytes - 1; i ++ ) {
+
+						blocks = blocks | ( byteData[ i ] << ( i * dataPointSize ) );
+
+					}
+
+					let headerSize = ( blocks + 3 ) * numBytes;
+					const padding = ( ( headerSize % 3 ) > 0 ) ? 3 - ( headerSize % 3 ) : 0;
+					headerSize = headerSize + padding;
+
+					const dataOffsets = [];
+					let currentOffset = headerSize;
+					dataOffsets.push( currentOffset );
+
+					// Get the blocks sizes after the compression.
+					// There are three blocks before c-size-i, so we skip 3*numBytes
+					const cSizeStart = 3 * numBytes;
+
+					for ( let i = 0; i < blocks; i ++ ) {
+
+						let currentBlockSize = byteData[ i * numBytes + cSizeStart ];
+
+						for ( let j = 1; j < numBytes - 1; j ++ ) {
+
+							currentBlockSize = currentBlockSize | ( byteData[ i * numBytes + cSizeStart + j ] << ( j * dataPointSize ) );
+
+						}
+
+						currentOffset = currentOffset + currentBlockSize;
+						dataOffsets.push( currentOffset );
+
+					}
+
+					for ( let i = 0; i < dataOffsets.length - 1; i ++ ) {
+
+						const data = fflate.unzlibSync( byteData.slice( dataOffsets[ i ], dataOffsets[ i + 1 ] ) );
+						content = data.buffer;
+
+						if ( ele.attributes.type === 'Float32' ) {
+
+							content = new Float32Array( content );
+							txt = Float32Concat( txt, content );
+
+						} else if ( ele.attributes.type === 'Int32' || ele.attributes.type === 'Int64' ) {
+
+							content = new Int32Array( content );
+							txt = Int32Concat( txt, content );
+
+						}
+
+					}
+
+					delete ele[ '#text' ];
+
+					if ( ele.attributes.type === 'Int64' ) {
+
+						if ( ele.attributes.format === 'binary' ) {
+
+							txt = txt.filter( function ( el, idx ) {
+
+								if ( idx % 2 !== 1 ) return true;
+
+							} );
+
+						}
+
+					}
+
+				} else {
+
+					if ( ele.attributes.format === 'binary' && ! compressed ) {
+
+						content = Base64toByteArray( ele[ '#text' ] );
+
+						//  VTP data for the uncompressed case has the following structure:
+						// [#bytes][DATA]
+						// where "[#bytes]" is an integer value specifying the number of bytes in the block of data following it.
+						content = content.slice( numBytes ).buffer;
+
+					} else {
+
+						if ( ele[ '#text' ] ) {
+
+							content = ele[ '#text' ].split( /\s+/ ).filter( function ( el ) {
+
+								if ( el !== '' ) return el;
+
+							} );
+
+						} else {
+
+							content = new Int32Array( 0 ).buffer;
+
+						}
+
+					}
+
+					delete ele[ '#text' ];
+
+					// Get the content and optimize it
+					if ( ele.attributes.type === 'Float32' ) {
+
+						txt = new Float32Array( content );
+
+					} else if ( ele.attributes.type === 'Int32' ) {
+
+						txt = new Int32Array( content );
+
+					} else if ( ele.attributes.type === 'Int64' ) {
+
+						txt = new Int32Array( content );
+
+						if ( ele.attributes.format === 'binary' ) {
+
+							txt = txt.filter( function ( el, idx ) {
+
+								if ( idx % 2 !== 1 ) return true;
+
+							} );
+
+						}
+
+					}
+
+				} // endif ( ele.attributes.format === 'binary' && compressed )
+
+				return txt;
+
+			}
+
+			// Main part
+			// Get Dom
+			const dom = new DOMParser().parseFromString( stringFile, 'application/xml' );
+
+			// Get the doc
+			const doc = dom.documentElement;
+			// Convert to json
+			const json = xmlToJson( doc );
+			let points = [];
+			let normals = [];
+			let indices = [];
+
+			if ( json.PolyData ) {
+
+				const piece = json.PolyData.Piece;
+				const compressed = json.attributes.hasOwnProperty( 'compressor' );
+
+				// Can be optimized
+				// Loop through the sections
+				const sections = [ 'PointData', 'Points', 'Strips', 'Polys' ];// +['CellData', 'Verts', 'Lines'];
+				let sectionIndex = 0;
+				const numberOfSections = sections.length;
+
+				while ( sectionIndex < numberOfSections ) {
+
+					const section = piece[ sections[ sectionIndex ] ];
+
+					// If it has a DataArray in it
+
+					if ( section && section.DataArray ) {
+
+						// Depending on the number of DataArrays
+
+						let arr;
+
+						if ( Array.isArray( section.DataArray ) ) {
+
+							arr = section.DataArray;
+
+						} else {
+
+							arr = [ section.DataArray ];
+
+						}
+
+						let dataArrayIndex = 0;
+						const numberOfDataArrays = arr.length;
+
+						while ( dataArrayIndex < numberOfDataArrays ) {
+
+							// Parse the DataArray
+							if ( ( '#text' in arr[ dataArrayIndex ] ) && ( arr[ dataArrayIndex ][ '#text' ].length > 0 ) ) {
+
+								arr[ dataArrayIndex ].text = parseDataArray( arr[ dataArrayIndex ], compressed );
+
+							}
+
+							dataArrayIndex ++;
+
+						}
+
+						switch ( sections[ sectionIndex ] ) {
+
+							// if iti is point data
+							case 'PointData':
+
+								{
+
+									const numberOfPoints = parseInt( piece.attributes.NumberOfPoints );
+									const normalsName = section.attributes.Normals;
+
+									if ( numberOfPoints > 0 ) {
+
+										for ( let i = 0, len = arr.length; i < len; i ++ ) {
+
+											if ( normalsName === arr[ i ].attributes.Name ) {
+
+												const components = arr[ i ].attributes.NumberOfComponents;
+												normals = new Float32Array( numberOfPoints * components );
+												normals.set( arr[ i ].text, 0 );
+
+											}
+
+										}
+
+									}
+
+								}
+
+								break;
+
+							// if it is points
+							case 'Points':
+
+								{
+
+									const numberOfPoints = parseInt( piece.attributes.NumberOfPoints );
+
+									if ( numberOfPoints > 0 ) {
+
+										const components = section.DataArray.attributes.NumberOfComponents;
+										points = new Float32Array( numberOfPoints * components );
+										points.set( section.DataArray.text, 0 );
+
+									}
+
+								}
+
+								break;
+
+							// if it is strips
+							case 'Strips':
+
+								{
+
+									const numberOfStrips = parseInt( piece.attributes.NumberOfStrips );
+
+									if ( numberOfStrips > 0 ) {
+
+										const connectivity = new Int32Array( section.DataArray[ 0 ].text.length );
+										const offset = new Int32Array( section.DataArray[ 1 ].text.length );
+										connectivity.set( section.DataArray[ 0 ].text, 0 );
+										offset.set( section.DataArray[ 1 ].text, 0 );
+
+										const size = numberOfStrips + connectivity.length;
+										indices = new Uint32Array( 3 * size - 9 * numberOfStrips );
+
+										let indicesIndex = 0;
+
+										for ( let i = 0, len = numberOfStrips; i < len; i ++ ) {
+
+											const strip = [];
+
+											for ( let s = 0, len1 = offset[ i ], len0 = 0; s < len1 - len0; s ++ ) {
+
+												strip.push( connectivity[ s ] );
+
+												if ( i > 0 ) len0 = offset[ i - 1 ];
+
+											}
+
+											for ( let j = 0, len1 = offset[ i ], len0 = 0; j < len1 - len0 - 2; j ++ ) {
+
+												if ( j % 2 ) {
+
+													indices[ indicesIndex ++ ] = strip[ j ];
+													indices[ indicesIndex ++ ] = strip[ j + 2 ];
+													indices[ indicesIndex ++ ] = strip[ j + 1 ];
+
+												} else {
+
+													indices[ indicesIndex ++ ] = strip[ j ];
+													indices[ indicesIndex ++ ] = strip[ j + 1 ];
+													indices[ indicesIndex ++ ] = strip[ j + 2 ];
+
+												}
+
+												if ( i > 0 ) len0 = offset[ i - 1 ];
+
+											}
+
+										}
+
+									}
+
+								}
+
+								break;
+
+							// if it is polys
+							case 'Polys':
+
+								{
+
+									const numberOfPolys = parseInt( piece.attributes.NumberOfPolys );
+
+									if ( numberOfPolys > 0 ) {
+
+										const connectivity = new Int32Array( section.DataArray[ 0 ].text.length );
+										const offset = new Int32Array( section.DataArray[ 1 ].text.length );
+										connectivity.set( section.DataArray[ 0 ].text, 0 );
+										offset.set( section.DataArray[ 1 ].text, 0 );
+
+										const size = numberOfPolys + connectivity.length;
+										indices = new Uint32Array( 3 * size - 9 * numberOfPolys );
+										let indicesIndex = 0, connectivityIndex = 0;
+										let i = 0, len0 = 0;
+										const len = numberOfPolys;
+
+										while ( i < len ) {
+
+											const poly = [];
+											let s = 0;
+											const len1 = offset[ i ];
+
+											while ( s < len1 - len0 ) {
+
+												poly.push( connectivity[ connectivityIndex ++ ] );
+												s ++;
+
+											}
+
+											let j = 1;
+
+											while ( j < len1 - len0 - 1 ) {
+
+												indices[ indicesIndex ++ ] = poly[ 0 ];
+												indices[ indicesIndex ++ ] = poly[ j ];
+												indices[ indicesIndex ++ ] = poly[ j + 1 ];
+												j ++;
+
+											}
+
+											i ++;
+											len0 = offset[ i - 1 ];
+
+										}
+
+									}
+
+								}
+
+								break;
+
+							default:
+								break;
+
+						}
+
+					}
+
+					sectionIndex ++;
+
+				}
+
+				const geometry = new BufferGeometry();
+				geometry.setIndex( new BufferAttribute( indices, 1 ) );
+				geometry.setAttribute( 'position', new BufferAttribute( points, 3 ) );
+
+				if ( normals.length === points.length ) {
+
+					geometry.setAttribute( 'normal', new BufferAttribute( normals, 3 ) );
+
+				}
+
+				return geometry;
+
+			} else {
+
+				throw new Error( 'Unsupported DATASET type' );
+
+			}
+
+		}
+
+		const textDecoder = new TextDecoder();
+
+		// get the 5 first lines of the files to check if there is the key word binary
+		const meta = textDecoder.decode( new Uint8Array( data, 0, 250 ) ).split( '\n' );
+
+		if ( meta[ 0 ].indexOf( 'xml' ) !== - 1 ) {
+
+			return parseXML( textDecoder.decode( data ) );
+
+		} else if ( meta[ 2 ].includes( 'ASCII' ) ) {
+
+			return parseASCII( textDecoder.decode( data ) );
+
+		} else {
+
+			return parseBinary( data );
+
+		}
+
+	}
+
+}
+
+export { VTKLoader };