three.js/examples/js/loaders/PCDLoader.js

/**
 * @author Filipe Caixeta / http://filipecaixeta.com.br
 *
 * Description: A THREE loader for PCD ascii and binary files.
 *
 * Limitations: Compressed binary files are not supported.
 *
 */

THREE.PCDLoader = function ( manager ) {

	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
	this.littleEndian = true;

};


THREE.PCDLoader.prototype = {

	constructor: THREE.PCDLoader,

	load: function ( url, onLoad, onProgress, onError ) {

		var scope = this;

		var loader = new THREE.FileLoader( scope.manager );
		loader.setResponseType( 'arraybuffer' );
		loader.load( url, function ( data ) {

			onLoad( scope.parse( data, url ) );

		}, onProgress, onError );

	},

	binarryToStr: function ( data ) {

		var charArray = new Uint8Array( data );

		if ( window.TextDecoder !== undefined ) {

			return new TextDecoder().decode( charArray );

		}

		var text = '';
		for ( var i = 0, il = data.byteLength; i < il; i ++ ) {

			text += String.fromCharCode( charArray[ i ] );

		}
		return text;

	},

	parseHeader: function ( data ) {

		var PCDheader = {};
		var result1 = data.search( /[\r\n]DATA\s(\S*)\s/i );
		var result2 = /[\r\n]DATA\s(\S*)\s/i.exec( data.substr( result1 - 1 ) );

		var i, l;

		PCDheader.data = result2[ 1 ];
		PCDheader.headerLen = result2[ 0 ].length + result1;
		PCDheader.str = data.substr( 0, PCDheader.headerLen );

		// remove comments

		PCDheader.str = PCDheader.str.replace( /\#.*/gi, '' );

		// parse

		PCDheader.version = /VERSION (.*)/i.exec( PCDheader.str );
		PCDheader.fields = /FIELDS (.*)/i.exec( PCDheader.str );
		PCDheader.size = /SIZE (.*)/i.exec( PCDheader.str );
		PCDheader.type = /TYPE (.*)/i.exec( PCDheader.str );
		PCDheader.count = /COUNT (.*)/i.exec( PCDheader.str );
		PCDheader.width = /WIDTH (.*)/i.exec( PCDheader.str );
		PCDheader.height = /HEIGHT (.*)/i.exec( PCDheader.str );
		PCDheader.viewpoint = /VIEWPOINT (.*)/i.exec( PCDheader.str );
		PCDheader.points = /POINTS (.*)/i.exec( PCDheader.str );

		// evaluate

		if ( PCDheader.version !== null )
			PCDheader.version = parseFloat( PCDheader.version[ 1 ] );

		if ( PCDheader.fields !== null )
			PCDheader.fields = PCDheader.fields[ 1 ].split( ' ' );

		if ( PCDheader.type !== null )
			PCDheader.type = PCDheader.type[ 1 ].split( ' ' );

		if ( PCDheader.width !== null )
			PCDheader.width = parseInt( PCDheader.width[ 1 ] );

		if ( PCDheader.height !== null )
			PCDheader.height = parseInt( PCDheader.height[ 1 ] );

		if ( PCDheader.viewpoint !== null )
			PCDheader.viewpoint = PCDheader.viewpoint[ 1 ];

		if ( PCDheader.points !== null )
			PCDheader.points = parseInt( PCDheader.points[ 1 ], 10 );

		if ( PCDheader.points === null )
			PCDheader.points = PCDheader.width * PCDheader.height;

		if ( PCDheader.size !== null ) {

			PCDheader.size = PCDheader.size[ 1 ].split( ' ' ).map( function ( x ) {

				return parseInt( x, 10 );

			} );

		}

		if ( PCDheader.count !== null ) {

			PCDheader.count = PCDheader.count[ 1 ].split( ' ' ).map( function ( x ) {

				return parseInt( x, 10 );

			} );

		} else {

			PCDheader.count = [];

			for ( i = 0, l = PCDheader.fields.length; i < l; i ++ ) {

				PCDheader.count.push( 1 );

			}

		}

		PCDheader.offset = {};

		var sizeSum = 0;

		for ( i = 0, l = PCDheader.fields.length; i < l; i ++ ) {

			if ( PCDheader.data === 'ascii' ) {

				PCDheader.offset[ PCDheader.fields[ i ] ] = i;

			} else {

				PCDheader.offset[ PCDheader.fields[ i ] ] = sizeSum;
				sizeSum += PCDheader.size[ i ];

			}

		}

		// for binary only

		PCDheader.rowSize = sizeSum;

		return PCDheader;

	},

	parse: function ( data, url ) {

		var dataView, offset;
		var i, l;

		var textData = this.binarryToStr( data );

		// parse header (always ascii format)

		var PCDheader = this.parseHeader( textData );

		// parse data

		var position = [];
		var normal = [];
		var color = [];

		// ascii

		if ( PCDheader.data === 'ascii' ) {

			offset = PCDheader.offset;
			var pcdData = textData.substr( PCDheader.headerLen );
			var lines = pcdData.split( '\n' );

			for ( i = 0, l = lines.length; i < l; i ++ ) {

				var line = lines[ i ].split( ' ' );

				if ( offset.x !== undefined ) {

					position.push( parseFloat( line[ offset.x ] ) );
					position.push( parseFloat( line[ offset.y ] ) );
					position.push( parseFloat( line[ offset.z ] ) );

				}

				if ( offset.rgb !== undefined ) {

					var c = new Float32Array( [ parseFloat( line[ offset.rgb ] ) ] );
					dataview = new DataView( c.buffer, 0 );
					color.push( dataview.getUint8( 0 ) / 255.0 );
					color.push( dataview.getUint8( 1 ) / 255.0 );
					color.push( dataview.getUint8( 2 ) / 255.0 );

				}

				if ( offset.normal_x !== undefined ) {

					normal.push( parseFloat( line[ offset.normal_x ] ) );
					normal.push( parseFloat( line[ offset.normal_y ] ) );
					normal.push( parseFloat( line[ offset.normal_z ] ) );

				}

			}

		}

		// binary

		if ( PCDheader.data === 'binary_compressed' ) {

			console.error( 'THREE.PCDLoader: binary_compressed files are not supported' );
			return;

		}

		if ( PCDheader.data === 'binary' ) {

			dataview = new DataView( data, PCDheader.headerLen );
			offset = PCDheader.offset;

			for ( i = 0, row = 0; i < PCDheader.points; i ++, row += PCDheader.rowSize ) {

				if ( offset.x !== undefined ) {

					position.push( dataview.getFloat32( row + offset.x, this.littleEndian ) );
					position.push( dataview.getFloat32( row + offset.y, this.littleEndian ) );
					position.push( dataview.getFloat32( row + offset.z, this.littleEndian ) );

				}

				if ( offset.rgb !== undefined ) {

					color.push( dataview.getUint8( row + offset.rgb + 0 ) / 255.0 );
					color.push( dataview.getUint8( row + offset.rgb + 1 ) / 255.0 );
					color.push( dataview.getUint8( row + offset.rgb + 2 ) / 255.0 );

				}

				if ( offset.normal_x !== undefined ) {

					normal.push( dataview.getFloat32( row + offset.normal_x, this.littleEndian ) );
					normal.push( dataview.getFloat32( row + offset.normal_y, this.littleEndian ) );
					normal.push( dataview.getFloat32( row + offset.normal_z, this.littleEndian ) );

				}

			}

		}

		// build geometry

		var geometry = new THREE.BufferGeometry();

		if ( position.length > 0 ) geometry.addAttribute( 'position', new THREE.Float32BufferAttribute( position, 3 ) );
		if ( normal.length > 0 ) geometry.addAttribute( 'normal', new THREE.Float32BufferAttribute( normal, 3 ) );
		if ( color.length > 0 ) geometry.addAttribute( 'color', new THREE.Float32BufferAttribute( color, 3 ) );

		geometry.computeBoundingSphere();

		// build material

		var material = new THREE.PointsMaterial( { size: 0.005 } );

		if ( color.length > 0 ) {

			material.vertexColors = true;

		} else {

			material.color.setHex( Math.random() * 0xffffff );

		}

		// build mesh

		var mesh = new THREE.Points( geometry, material );
		var name = url.split( '' ).reverse().join( '' );
		name = /([^\/]*)/.exec( name );
		name = name[ 1 ].split( '' ).reverse().join( '' );
		mesh.name = name;

		return mesh;

	}

};