text: /**
   * @author mrdoob / http://mrdoob.com/
   * @author Alex Pletzer
   */
  
  THREE.VTKLoader = function( manager ) {
  
  	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
  
  };
  
  THREE.VTKLoader.prototype = {
  
  	constructor: THREE.VTKLoader,
  
  	load: function ( url, onLoad, onProgress, onError ) {
  
  		var scope = this;
  
  		var loader = new THREE.XHRLoader( scope.manager );
  		loader.setResponseType( 'arraybuffer' );
  		loader.load( url, function( text ) {
  
  			onLoad( scope.parse( text ) );
  
  		}, onProgress, onError );
  
  	},
  
  	parse: function ( data ) {
  
  		function parseASCII( data ) {
  
  			// connectivity of the triangles
  			var indices = [];
  
  			// triangles vertices
  			var positions = [];
  
  			// red, green, blue colors in the range 0 to 1
  			var colors = [];
  
  			// normal vector, one per vertex
  			var normals = [];
  
  			var result;
  
  			// pattern for reading vertices, 3 floats or integers
  			var 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
  			var patConnectivity = /^(\d+)\s+([\s\d]*)/;
  
  			// indicates start of vertex data section
  			var patPOINTS = /^POINTS /;
  
  			// indicates start of polygon connectivity section
  			var patPOLYGONS = /^POLYGONS /;
  
  			// indicates start of triangle strips section
  			var patTRIANGLE_STRIPS = /^TRIANGLE_STRIPS /;
  
  			// POINT_DATA number_of_values
  			var patPOINT_DATA = /^POINT_DATA[ ]+(\d+)/;
  
  			// CELL_DATA number_of_polys
  			var patCELL_DATA = /^CELL_DATA[ ]+(\d+)/;
  
  			// Start of color section
  			var patCOLOR_SCALARS = /^COLOR_SCALARS[ ]+(\w+)[ ]+3/;
  
  			// NORMALS Normals float
  			var patNORMALS = /^NORMALS[ ]+(\w+)[ ]+(\w+)/;
  
  			var inPointsSection = false;
  			var inPolygonsSection = false;
  			var inTriangleStripSection = false;
  			var inPointDataSection = false;
  			var inCellDataSection = false;
  			var inColorSection = false;
  			var inNormalsSection = false;
  
  			var lines = data.split( '\n' );
  
  			for ( var i in lines ) {
  
  				var line = lines[ i ];
  
  				if ( inPointsSection ) {
  
  					// get the vertices
  					while ( ( result = pat3Floats.exec( line ) ) !== null ) {
  
  						var x = parseFloat( result[ 1 ] );
  						var y = parseFloat( result[ 2 ] );
  						var z = parseFloat( result[ 3 ] );
  						positions.push( x, y, z );
  
  					}
  
  				} else if ( inPolygonsSection ) {
  
  					if ( ( result = patConnectivity.exec( line ) ) !== null ) {
  
  						// numVertices i0 i1 i2 ...
  						var numVertices = parseInt( result[ 1 ] );
  						var inds = result[ 2 ].split( /\s+/ );
  
  						if ( numVertices >= 3 ) {
  
  							var i0 = parseInt( inds[ 0 ] );
  							var i1, i2;
  							var k = 1;
  							// split the polygon in numVertices - 2 triangles
  							for ( var j = 0; j < numVertices - 2; ++ j ) {
  
  								i1 = parseInt( inds[ k ] );
  								i2 = parseInt( inds[ k + 1 ] );
  								indices.push( i0, i1, i2 );
  								k ++;
  
  							}
  
  						}
  
  					}
  
  				} else if ( inTriangleStripSection ) {
  
  					if ( ( result = patConnectivity.exec( line ) ) !== null ) {
  
  						// numVertices i0 i1 i2 ...
  						var numVertices = parseInt( result[ 1 ] );
  						var inds = result[ 2 ].split( /\s+/ );
  
  						if ( numVertices >= 3 ) {
  
  							var i0, i1, i2;
  							// split the polygon in numVertices - 2 triangles
  							for ( var j = 0; j < numVertices - 2; j ++ ) {
  
  								if ( j % 2 === 1 ) {
  
  									i0 = parseInt( inds[ j ] );
  									i1 = parseInt( inds[ j + 2 ] );
  									i2 = parseInt( inds[ j + 1 ] );
  									indices.push( i0, i1, i2 );
  
  								} else {
  
  									i0 = parseInt( inds[ j ] );
  									i1 = parseInt( inds[ j + 1 ] );
  									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 ) {
  
  							var r = parseFloat( result[ 1 ] );
  							var g = parseFloat( result[ 2 ] );
  							var b = parseFloat( result[ 3 ] );
  							colors.push( r, g, b );
  
  						}
  
  					} else if ( inNormalsSection ) {
  
  						// Get the normal vectors
  
  						while ( ( result = pat3Floats.exec( line ) ) !== null ) {
  
  							var nx = parseFloat( result[ 1 ] );
  							var ny = parseFloat( result[ 2 ] );
  							var 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;
  
  				}
  
  			}
  
  			var geometry;
  			var stagger = 'point';
  
  			if ( colors.length == indices.length ) {
  
  				stagger = 'cell';
  
  			}
  
  			if ( stagger == 'point' ) {
  
  				// Nodal. Use BufferGeometry
  				geometry = new THREE.BufferGeometry();
  				geometry.setIndex( new THREE.BufferAttribute( new Uint32Array( indices ), 1 ) );
  				geometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( positions ), 3 ) );
  
  				if ( colors.length == positions.length ) {
  
  					geometry.addAttribute( 'color', new THREE.BufferAttribute( new Float32Array( colors ), 3 ) );
  
  				}
  
  				if ( normals.length == positions.length ) {
  
  					geometry.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( normals ), 3 ) );
  
  				}
  
  			} else {
  
  				// Cell centered colors. The only way to attach a solid color to each triangle
  				// is to use Geometry, which is less efficient than BufferGeometry
  				geometry = new THREE.Geometry();
  
  				var numTriangles = indices.length / 3;
  				var numPoints = positions.length / 3;
  				var va, vb, vc;
  				var face;
  				var ia, ib, ic;
  				var x, y, z;
  				var r, g, b;
  
  				for ( var j = 0; j < numPoints; ++ j ) {
  
  					x = positions[ 3 * j + 0 ];
  					y = positions[ 3 * j + 1 ];
  					z = positions[ 3 * j + 2 ];
  					geometry.vertices.push( new THREE.Vector3( x, y, z ) );
  
  				}
  
  				for ( var i = 0; i < numTriangles; ++ i ) {
  
  					ia = indices[ 3 * i + 0 ];
  					ib = indices[ 3 * i + 1 ];
  					ic = indices[ 3 * i + 2 ];
  					geometry.faces.push( new THREE.Face3( ia, ib, ic ) );
  
  				}
  
  				if ( colors.length == numTriangles * 3 ) {
  
  					for ( var i = 0; i < numTriangles; ++ i ) {
  
  						face = geometry.faces[ i ];
  						r = colors[ 3 * i + 0 ];
  						g = colors[ 3 * i + 1 ];
  						b = colors[ 3 * i + 2 ];
  						face.color = new THREE.Color().setRGB( r, g, b );
  
  					}
  
  				}
  
  			}
  
  			return geometry;
  
  		}
  
  		function parseBinary( data ) {
  
  			var count, pointIndex, i, numberOfPoints, pt, s;
  			var buffer = new Uint8Array ( data );
  			var dataView = new DataView ( data );
  
  			// Points and normals, by default, are empty
  			var points = [];
  			var normals = [];
  			var indices = [];
  
  			// Going to make a big array of strings
  			var vtk = [];
  			var index = 0;
  
  			function findString( buffer, start ) {
  
  				var index = start;
  				var c = buffer[ index ];
  				var s = [];
  				while ( c != 10 ) {
  
  					s.push ( String.fromCharCode ( c ) );
  					index ++;
  					c = buffer[ index ];
  
  				}
  
  				return { start: start,
  						end: index,
  						next: index + 1,
  						parsedString: s.join( '' ) };
  
  			}
  
  			var state, line;
  
  			while ( true ) {
  
  				// Get a string
  				state = findString ( buffer, index );
  				line = state.parsedString;
  
  				if ( line.indexOf ( 'POINTS' ) === 0 ) {
  
  					vtk.push ( line );
  					// Add the points
  					numberOfPoints = parseInt ( line.split( ' ' )[ 1 ], 10 );
  
  					// Each point is 3 4-byte floats
  					count = numberOfPoints * 4 * 3;
  
  					points = new Float32Array( numberOfPoints * 3 );
  
  					pointIndex = state.next;
  					for ( 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 ) {
  
  					var numberOfStrips = parseInt ( line.split( ' ' )[ 1 ], 10 );
  					var size = parseInt ( line.split ( ' ' )[ 2 ], 10 );
  					// 4 byte integers
  					count = size * 4;
  
  					indices = new Uint32Array( 3 * size - 9 * numberOfStrips );
  					var indicesIndex = 0;
  
  					pointIndex = state.next;
  					for ( i = 0; i < numberOfStrips; i ++ ) {
  
  						// For each strip, read the first value, then record that many more points
  						var indexCount = dataView.getInt32( pointIndex, false );
  						var strip = [];
  						pointIndex += 4;
  						for ( s = 0; s < indexCount; s ++ ) {
  
  							strip.push ( dataView.getInt32( pointIndex, false ) );
  							pointIndex += 4;
  
  						}
  
  						// retrieves the n-2 triangles from the triangle strip
  						for ( var 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 ) {
  
  					var numberOfStrips = parseInt ( line.split( ' ' )[ 1 ], 10 );
  					var size = parseInt ( line.split ( ' ' )[ 2 ], 10 );
  					// 4 byte integers
  					count = size * 4;
  
  					indices = new Uint32Array( 3 * size - 9 * numberOfStrips );
  					var indicesIndex = 0;
  
  					pointIndex = state.next;
  					for ( i = 0; i < numberOfStrips; i ++ ) {
  
  						// For each strip, read the first value, then record that many more points
  						var indexCount = dataView.getInt32( pointIndex, false );
  						var strip = [];
  						pointIndex += 4;
  						for ( s = 0; s < indexCount; s ++ ) {
  
  							strip.push ( dataView.getInt32( pointIndex, false ) );
  							pointIndex += 4;
  
  						}
  						var i0 = strip[ 0 ];
  						// divide the polygon in n-2 triangle
  						for ( var 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 ) {
  
  					numberOfPoints = parseInt ( line.split( ' ' )[ 1 ], 10 );
  
  					// Grab the next line
  					state = findString ( buffer, state.next );
  
  					// Now grab the binary data
  					count = numberOfPoints * 4 * 3;
  
  					normals = new Float32Array( numberOfPoints * 3 );
  					pointIndex = state.next;
  					for ( 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;
  
  				}
  
  			}
  
  			var geometry = new THREE.BufferGeometry();
  			geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );
  			geometry.addAttribute( 'position', new THREE.BufferAttribute( points, 3 ) );
  
  			if ( normals.length == points.length ) {
  
  				geometry.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
  
  			}
  
  			return geometry;
  
  		}
  
  		function parseXML( stringFile ) {
  
  			// Changes XML to JSON, based on https://davidwalsh.name/convert-xml-json
  
  			function xmlToJson( xml ) {
  
  				// Create the return object
  				var obj = {};
  
  				if ( xml.nodeType == 1 ) { // element
  
  					// do attributes
  
  					if ( xml.attributes ) {
  
  						if ( xml.attributes.length > 0 ) {
  
  							obj[ 'attributes' ] = {};
  
  							for ( var j = 0; j < xml.attributes.length; j ++ ) {
  
  								var 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 ( var i = 0; i < xml.childNodes.length; i ++ ) {
  
  						var item = xml.childNodes.item( i );
  						var nodeName = item.nodeName;
  
  						if ( typeof( obj[ nodeName ] ) === 'undefined' ) {
  
  							var tmp = xmlToJson( item );
  
  							if ( tmp !== '' ) obj[ nodeName ] = tmp;
  
  						} else {
  
  							if ( typeof( obj[ nodeName ].push ) === 'undefined' ) {
  
  								var old = obj[ nodeName ];
  								obj[ nodeName ] = [ old ];
  
  							}
  
  							var tmp = xmlToJson( item );
  
  							if ( tmp !== '' ) obj[ nodeName ].push( tmp );
  
  						}
  
  					}
  
  				}
  
  				return obj;
  
  			}
  
  			// Taken from Base64-js
  			function Base64toByteArray( b64 ) {
  
  				var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
  				var i;
  				var lookup = [];
  				var revLookup = [];
  				var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
  				var len = code.length;
  
  				for ( i = 0; i < len; i ++ ) {
  
  					lookup[ i ] = code[ i ];
  
  				}
  
  				for ( i = 0; i < len; ++ i ) {
  
  					revLookup[ code.charCodeAt( i ) ] = i;
  
  				}
  
  				revLookup[ '-'.charCodeAt( 0 ) ] = 62;
  				revLookup[ '_'.charCodeAt( 0 ) ] = 63;
  
  				var j, l, tmp, placeHolders, arr;
  				var len = b64.length;
  
  				if ( len % 4 > 0 ) {
  
  					throw new Error( 'Invalid string. Length must be a multiple of 4' );
  
  				}
  
  				placeHolders = b64[ len - 2 ] === '=' ? 2 : b64[ len - 1 ] === '=' ? 1 : 0;
  				arr = new Arr( len * 3 / 4 - placeHolders );
  				l = placeHolders > 0 ? len - 4 : len;
  
  				var L = 0;
  
  				for ( i = 0, j = 0; i < l; i += 4, j += 3 ) {
  
  					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 ) {
  
  					tmp = ( revLookup[ b64.charCodeAt( i ) ] << 2 ) | ( revLookup[ b64.charCodeAt( i + 1 ) ] >> 4 );
  					arr[ L ++ ] = tmp & 0xFF;
  
  				} else if ( placeHolders === 1 ) {
  
  					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 ) {
  
  				// Check the format
  
  				if ( ele.attributes.format == 'binary' ) {
  
  					if ( compressed ) {
  
  						// Split the blob_header and compressed Data
  						if ( ele[ '#text' ].indexOf( '==' ) != - 1 ) {
  
  							var data = ele[ '#text' ].split( '==' );
  
  							// console.log( data );
  
  							if ( data.length == 2 ) {
  
  								var blob = data.shift();
  								var content = data.shift();
  
  								if ( content === '' ) {
  
  									content = blob + '==';
  
  								}
  
  							} else if ( data.length > 2 ) {
  
  								var blob = data.shift();
  								var content = data.shift();
  								content = content + '==';
  
  							} else if ( data.length < 2 ) {
  
  								var content = data.shift();
  								content = content + '==';
  
  							}
  
  							// Convert to bytearray
  							var arr = Base64toByteArray( content );
  
  							// decompress
  							var inflate = new Zlib.Inflate( arr, { resize: true, verify: true } );
  							var content = inflate.decompress();
  
  						} else {
  
  							var content = Base64toByteArray( ele[ '#text' ] );
  
  						}
  
  					} else {
  
  						var content = Base64toByteArray( ele[ '#text' ] );
  
  					}
  
  					var content = content.buffer;
  
  				} else {
  
  					if ( ele[ '#text' ] ) {
  
  						var content = ele[ '#text' ].replace( /\n/g, ' ' ).split( ' ' ).filter( function ( el, idx, arr ) {
  
  							if ( el !== '' ) return el;
  
  						} );
  
  					} else {
  
  						var content = new Int32Array( 0 ).buffer;
  
  					}
  
  				}
  
  				delete ele[ '#text' ];
  
  				// Get the content and optimize it
  
  				if ( ele.attributes.type == 'Float32' ) {
  
  					var txt = new Float32Array( content );
  
  					if ( ele.attributes.format == 'binary' ) {
  
  						if ( ! compressed ) {
  
  							txt = txt.filter( function( el, idx, arr ) {
  
  								if ( idx !== 0 ) return true;
  
  							} );
  
  						}
  
  					}
  
  				} else if ( ele.attributes.type === 'Int64' ) {
  
  					var txt = new Int32Array( content );
  
  					if ( ele.attributes.format == 'binary' ) {
  
  						if ( ! compressed ) {
  
  							txt = txt.filter( function ( el, idx, arr ) {
  
  								if ( idx !== 0 ) return true;
  
  							} );
  
  						}
  
  						txt = txt.filter( function ( el, idx, arr ) {
  
  							if ( idx % 2 !== 1 ) return true;
  
  						} );
  
  					}
  
  				}
  
  				// console.log( txt );
  
  				return txt;
  
  			}
  
  			// Main part
  			// Get Dom
  			var dom = null;
  
  			if ( window.DOMParser ) {
  
  				try {
  
  					dom = ( new DOMParser() ).parseFromString( stringFile, 'text/xml' );
  
  				} catch ( e ) {
  
  					dom = null;
  
  				}
  
  			} else if ( window.ActiveXObject ) {
  
  				try {
  
  					dom = new ActiveXObject( 'Microsoft.XMLDOM' );
  					dom.async = false;
  
  					if ( ! dom.loadXML( xml ) ) {
  
  						throw new Error( dom.parseError.reason + dom.parseError.srcText );
  
  					}
  
  				} catch ( e ) {
  
  					dom = null;
  
  				}
  
  			} else {
  
  				throw new Error( 'Cannot parse xml string!' );
  
  			}
  
  			// Get the doc
  			var doc = dom.documentElement;
  			// Convert to json
  			var json = xmlToJson( doc );
  			var points = [];
  			var normals = [];
  			var indices = [];
  
  			if ( json.PolyData ) {
  
  				var piece = json.PolyData.Piece;
  				var compressed = json.attributes.hasOwnProperty( 'compressor' );
  
  				// Can be optimized
  				// Loop through the sections
  				var sections = [ 'PointData', 'Points', 'Strips', 'Polys' ];// +['CellData', 'Verts', 'Lines'];
  				var sectionIndex = 0, numberOfSections = sections.length;
  
  				while ( sectionIndex < numberOfSections ) {
  
  					var section = piece[ sections[ sectionIndex ] ];
  
  					// If it has a DataArray in it
  
  					if ( section.DataArray ) {
  
  						// Depending on the number of DataArrays
  
  						if ( Object.prototype.toString.call( section.DataArray ) === '[object Array]' ) {
  
  							var arr = section.DataArray;
  
  						} else {
  
  							var arr = [ section.DataArray ];
  
  						}
  
  						var dataArrayIndex = 0, numberOfDataArrays = arr.length;
  
  						while ( dataArrayIndex < numberOfDataArrays ) {
  
  							// Parse the DataArray
  							arr[ dataArrayIndex ].text = parseDataArray( arr[ dataArrayIndex ], compressed );
  							dataArrayIndex ++;
  
  						}
  
  						switch ( sections[ sectionIndex ] ) {
  
  							// if iti is point data
  							case 'PointData':
  
  								var numberOfPoints = parseInt( piece.attributes.NumberOfPoints );
  								var normalsName = section.attributes.Normals;
  
  								if ( numberOfPoints > 0 ) {
  
  									for ( var i = 0, len = arr.length; i < len; i ++ ) {
  
  										if ( normalsName == arr[ i ].attributes.Name ) {
  
  											var components = arr[ i ].attributes.NumberOfComponents;
  											normals = new Float32Array( numberOfPoints * components );
  											normals.set( arr[ i ].text, 0 );
  
  										}
  
  									}
  
  								}
  
  								// console.log('Normals', normals);
  
  								break;
  
  							// if it is points
  							case 'Points':
  
  								var numberOfPoints = parseInt( piece.attributes.NumberOfPoints );
  
  								if ( numberOfPoints > 0 ) {
  
  									var components = section.DataArray.attributes.NumberOfComponents;
  									points = new Float32Array( numberOfPoints * components );
  									points.set( section.DataArray.text, 0 );
  
  								}
  
  								// console.log('Points', points);
  
  								break;
  
  							// if it is strips
  							case 'Strips':
  
  								var numberOfStrips = parseInt( piece.attributes.NumberOfStrips );
  
  								if ( numberOfStrips > 0 ) {
  
  									var connectivity = new Int32Array( section.DataArray[ 0 ].text.length );
  									var offset = new Int32Array( section.DataArray[ 1 ].text.length );
  									connectivity.set( section.DataArray[ 0 ].text, 0 );
  									offset.set( section.DataArray[ 1 ].text, 0 );
  
  									var size = numberOfStrips + connectivity.length;
  									indices = new Uint32Array( 3 * size - 9 * numberOfStrips );
  
  									var indicesIndex = 0;
  
  									for ( var i = 0,len = numberOfStrips; i < len; i ++ ) {
  
  										var strip = [];
  
  										for ( var s = 0, len1 = offset[ i ], len0 = 0; s < len1 - len0; s ++ ) {
  
  											strip.push ( connectivity[ s ] );
  
  											if ( i > 0 ) len0 = offset[ i - 1 ];
  
  										}
  
  										for ( var 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 ];
  
  										}
  
  									}
  
  								}
  
  								//console.log('Strips', indices);
  
  								break;
  
  							// if it is polys
  							case 'Polys':
  
  								var numberOfPolys = parseInt( piece.attributes.NumberOfPolys );
  
  								if ( numberOfPolys > 0 ) {
  
  									var connectivity = new Int32Array( section.DataArray[ 0 ].text.length );
  									var offset = new Int32Array( section.DataArray[ 1 ].text.length );
  									connectivity.set( section.DataArray[ 0 ].text, 0 );
  									offset.set( section.DataArray[ 1 ].text, 0 );
  
  									var size = numberOfPolys + connectivity.length;
  									indices = new Uint32Array( 3 * size - 9 * numberOfPolys );
  									var indicesIndex = 0, connectivityIndex = 0;
  									var i = 0,len = numberOfPolys, len0 = 0;
  
  									while ( i < len ) {
  
  										var poly = [];
  										var s = 0, len1 = offset[ i ];
  
  										while ( s < len1 - len0 ) {
  
  											poly.push( connectivity[ connectivityIndex ++ ] );
  											s ++;
  
  										}
  
  										var 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 ];
  
  									}
  
  								}
  								//console.log('Polys', indices);
  								break;
  
  							default:
  								break;
  
  						}
  
  					}
  
  					sectionIndex ++;
  
  				}
  
  				var geometry = new THREE.BufferGeometry();
  				geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );
  				geometry.addAttribute( 'position', new THREE.BufferAttribute( points, 3 ) );
  
  				if ( normals.length == points.length ) {
  
  					geometry.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
  
  				}
  
  				// console.log( json );
  
  				return geometry;
  
  			} else {
  
  				// TODO for vtu,vti,and other xml formats
  
  			}
  
  		}
  
  		function getStringFile( data ) {
  
  			var stringFile = '';
  			var charArray = new Uint8Array( data );
  			var i = 0;
  			var len = charArray.length;
  
  			while ( len -- ) {
  
  				stringFile += String.fromCharCode( charArray[ i ++ ] );
  
  			}
  
  			return stringFile;
  
  		}
  
  		// get the 5 first lines of the files to check if there is the key word binary
  		var meta = String.fromCharCode.apply( null, new Uint8Array( data, 0, 250 ) ).split( '\n' );
  
  		if ( meta[ 0 ].indexOf( 'xml' ) !== - 1 ) {
  
  			return parseXML( getStringFile( data ) );
  
  		} else if ( meta[ 2 ].includes( 'ASCII' ) ) {
  
  			return parseASCII( getStringFile( data ) );
  
  		} else {
  
  			return parseBinary( data );
  
  		}
  
  	}
  
  };
  
  THREE.EventDispatcher.prototype.apply( THREE.VTKLoader.prototype );
  