three.js/examples/js/loaders/VTKLoader.js

/**
 * Origin: https://github.com/mrdoob/three.js/blob/af21991fc7c4e1d35d6a93031707273d937af0f9/examples/js/loaders/VTKLoader.js
 * @author mrdoob / http://mrdoob.com/ and 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 ) {
	
		// Will we bump into trouble reading the whole file into memory?
		var scope = this;
		var loader = new THREE.XHRLoader( scope.manager );
		loader.setCrossOrigin( this.crossOrigin );
		
		loader.load( url, function ( text ) {
		
			onLoad( scope.parse( text ) );
			
		}, 
		
		onProgress, onError );
		
	},

	setCrossOrigin: function ( value ) {
	
		this.crossOrigin = value;
		
	},

	parse: function ( 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 /;

		// 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 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 ( 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;
				
			} else if ( patPOINTS.exec( line ) !== null ) {
			
				inPolygonsSection = false;
				inPointsSection = true;
				
			} else if ( patPOINT_DATA.exec( line ) !== null ) {
			
				inPointDataSection = true;
				inPointsSection = false;
				inPolygonsSection = false;
				
			} else if ( patCELL_DATA.exec( line ) !== null ) {
			
				inCellDataSection = true;
				inPointsSection = false;
				inPolygonsSection = false;
				
			} else if ( patCOLOR_SCALARS.exec( line ) !== null ) {
			
				inColorSection = true;
				inNormalsSection = false;
				inPointsSection = false;
				inPolygonsSection = false;
				
			} else if ( patNORMALS.exec( line ) !== null ) {
			
				inNormalsSection = true;
				inColorSection = false;
				inPointsSection = false;
				inPolygonsSection = false;
				
			}
			
		}

		var geometry;
		var stagger = 'point';

		if ( colors.length == indices.length ) {
		
			stagger = 'cell';
			
		}

		if ( stagger == 'point' ) {
		
			// Nodal. Use BufferGeometry
			geometry = new THREE.BufferGeometry();
			geometry.addAttribute( 'index', new THREE.BufferAttribute( new ( indices.length > 65535 ? Uint32Array : Uint16Array )( 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;
	}
};

THREE.EventDispatcher.prototype.apply( THREE.VTKLoader.prototype );