Refactored PLYLoader.

examples/js/loaders/PLYLoader.js

@@ -1,8 +1,8 @@
 /**
  * @author Wei Meng / http://about.me/menway
  *
- * Description: A THREE loader for PLY ASCII files (known as the Polygon File Format or the Stanford Triangle Format).
- *
+ * Description: A THREE loader for PLY ASCII files (known as the Polygon
+ * File Format or the Stanford Triangle Format).
  *
  * Limitations: ASCII decoding assumes file is UTF-8.
  *
@@ -59,418 +59,417 @@ THREE.PLYLoader.prototype = {
 
 	},
 
-	bin2str: function ( buf ) {
+	parse: function ( data ) {
 
-		var array_buffer = new Uint8Array( buf );
-		var str = '';
-		for ( var i = 0; i < buf.byteLength; i ++ ) {
+		function isASCII( data ) {
 
-			str += String.fromCharCode( array_buffer[ i ] ); // implicitly assumes little-endian
+			var header = parseHeader( bin2str( data ) );
+			return header.format === "ascii";
 
 		}
 
-		return str;
+		function bin2str( buf ) {
 
-	},
+			var array_buffer = new Uint8Array( buf );
+			var str = '';
 
-	isASCII: function( data ) {
+			for ( var i = 0; i < buf.byteLength; i ++ ) {
 
-		var header = this.parseHeader( this.bin2str( data ) );
+				str += String.fromCharCode( array_buffer[ i ] ); // implicitly assumes little-endian
 
-		return header.format === "ascii";
+			}
 
-	},
+			return str;
 
-	parse: function ( data ) {
+		}
 
-		if ( data instanceof ArrayBuffer ) {
+		function parseHeader( data ) {
 
-			return this.isASCII( data )
-				? this.parseASCII( this.bin2str( data ) )
-				: this.parseBinary( data );
+			var patternHeader = /ply([\s\S]*)end_header\s/;
+			var headerText = "";
+			var headerLength = 0;
+			var result = patternHeader.exec( data );
 
-		} else {
+			if ( result !== null ) {
 
-			return this.parseASCII( data );
+				headerText = result [ 1 ];
+				headerLength = result[ 0 ].length;
 
-		}
+			}
 
-	},
+			var header = {
+				comments: [],
+				elements: [],
+				headerLength: headerLength
+			};
 
-	parseHeader: function ( data ) {
+			var lines = headerText.split( '\n' );
+			var currentElement;
+			var lineType, lineValues;
 
-		var patternHeader = /ply([\s\S]*)end_header\s/;
-		var headerText = "";
-		var headerLength = 0;
-		var result = patternHeader.exec( data );
-		if ( result !== null ) {
+			function make_ply_element_property( propertValues, propertyNameMapping ) {
 
-			headerText = result [ 1 ];
-			headerLength = result[ 0 ].length;
+				var property = { type: propertValues[ 0 ] };
 
-		}
+				if ( property.type === 'list' ) {
 
-		var header = {
-			comments: [],
-			elements: [],
-			headerLength: headerLength
-		};
+					property.name = propertValues[ 3 ];
+					property.countType = propertValues[ 1 ];
+					property.itemType = propertValues[ 2 ];
 
-		var lines = headerText.split( '\n' );
-		var currentElement = undefined;
-		var lineType, lineValues;
+				} else {
 
-		function make_ply_element_property( propertValues, propertyNameMapping ) {
+					property.name = propertValues[ 1 ];
 
-			var property = {
-				type: propertValues[ 0 ]
-			};
+				}
 
-			if ( property.type === 'list' ) {
+				if ( property.name in propertyNameMapping ) {
 
-				property.name = propertValues[ 3 ];
-				property.countType = propertValues[ 1 ];
-				property.itemType = propertValues[ 2 ];
+					property.name = propertyNameMapping[ property.name ];
 
-			} else {
+				}
 
-				property.name = propertValues[ 1 ];
+				return property;
 
 			}
 
-			if ( property.name in propertyNameMapping ) {
+			for ( var i = 0; i < lines.length; i ++ ) {
 
-				property.name = propertyNameMapping[ property.name ];
+				var line = lines[ i ];
+				line = line.trim();
 
-			}
+				if ( line === "" ) continue;
 
-			return property;
+				lineValues = line.split( /\s+/ );
+				lineType = lineValues.shift();
+				line = lineValues.join( " " );
 
-		}
+				switch ( lineType ) {
 
-		for ( var i = 0; i < lines.length; i ++ ) {
+					case "format":
 
-			var line = lines[ i ];
-			line = line.trim();
-			if ( line === "" ) {
+						header.format = lineValues[ 0 ];
+						header.version = lineValues[ 1 ];
 
-				continue;
+						break;
 
-			}
-			lineValues = line.split( /\s+/ );
-			lineType = lineValues.shift();
-			line = lineValues.join( " " );
+					case "comment":
 
-			switch ( lineType ) {
+						header.comments.push( line );
 
-			case "format":
+						break;
 
-				header.format = lineValues[ 0 ];
-				header.version = lineValues[ 1 ];
+					case "element":
 
-				break;
+						if ( currentElement !== undefined ) {
 
-			case "comment":
+							header.elements.push( currentElement );
 
-				header.comments.push( line );
+						}
 
-				break;
+						currentElement = {};
+						currentElement.name = lineValues[ 0 ];
+						currentElement.count = parseInt( lineValues[ 1 ] );
+						currentElement.properties = [];
 
-			case "element":
+						break;
 
-				if ( ! ( currentElement === undefined ) ) {
+					case "property":
 
-					header.elements.push( currentElement );
+						currentElement.properties.push( make_ply_element_property( lineValues, scope.propertyNameMapping ) );
 
-				}
+						break;
 
-				currentElement = Object();
-				currentElement.name = lineValues[ 0 ];
-				currentElement.count = parseInt( lineValues[ 1 ] );
-				currentElement.properties = [];
 
-				break;
+					default:
 
-			case "property":
+						console.log( "unhandled", lineType, lineValues );
 
-				currentElement.properties.push( make_ply_element_property( lineValues, this.propertyNameMapping ) );
-
-				break;
+				}
 
+			}
 
-			default:
+			if ( currentElement !== undefined ) {
 
-				console.log( "unhandled", lineType, lineValues );
+				header.elements.push( currentElement );
 
 			}
 
-		}
-
-		if ( ! ( currentElement === undefined ) ) {
-
-			header.elements.push( currentElement );
+			return header;
 
 		}
 
-		return header;
-
-	},
+		function parseASCIINumber( n, type ) {
 
-	parseASCIINumber: function ( n, type ) {
+			switch ( type ) {
 
-		switch ( type ) {
+			case 'char': case 'uchar': case 'short': case 'ushort': case 'int': case 'uint':
+			case 'int8': case 'uint8': case 'int16': case 'uint16': case 'int32': case 'uint32':
 
-		case 'char': case 'uchar': case 'short': case 'ushort': case 'int': case 'uint':
-		case 'int8': case 'uint8': case 'int16': case 'uint16': case 'int32': case 'uint32':
+				return parseInt( n );
 
-			return parseInt( n );
+			case 'float': case 'double': case 'float32': case 'float64':
 
-		case 'float': case 'double': case 'float32': case 'float64':
+				return parseFloat( n );
 
-			return parseFloat( n );
+			}
 
 		}
 
-	},
+		function parseASCIIElement( properties, line ) {
 
-	parseASCIIElement: function ( properties, line ) {
+			var values = line.split( /\s+/ );
 
-		var values = line.split( /\s+/ );
+			var element = {};
 
-		var element = Object();
+			for ( var i = 0; i < properties.length; i ++ ) {
 
-		for ( var i = 0; i < properties.length; i ++ ) {
+				if ( properties[ i ].type === "list" ) {
 
-			if ( properties[ i ].type === "list" ) {
+					var list = [];
+					var n = parseASCIINumber( values.shift(), properties[ i ].countType );
 
-				var list = [];
-				var n = this.parseASCIINumber( values.shift(), properties[ i ].countType );
+					for ( var j = 0; j < n; j ++ ) {
 
-				for ( var j = 0; j < n; j ++ ) {
+						list.push( parseASCIINumber( values.shift(), properties[ i ].itemType ) );
 
-					list.push( this.parseASCIINumber( values.shift(), properties[ i ].itemType ) );
+					}
 
-				}
+					element[ properties[ i ].name ] = list;
 
-				element[ properties[ i ].name ] = list;
+				} else {
 
-			} else {
+					element[ properties[ i ].name ] = parseASCIINumber( values.shift(), properties[ i ].type );
 
-				element[ properties[ i ].name ] = this.parseASCIINumber( values.shift(), properties[ i ].type );
+				}
 
 			}
 
+			return element;
+
 		}
 
-		return element;
+		function parseASCII( data ) {
 
-	},
+			// PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
 
-	parseASCII: function ( data ) {
+			var geometry = new THREE.Geometry();
 
-		// PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
+			var result;
 
-		var geometry = new THREE.Geometry();
+			var header = parseHeader( data );
 
-		var result;
+			var patternBody = /end_header\s([\s\S]*)$/;
+			var body = "";
+			if ( ( result = patternBody.exec( data ) ) !== null ) {
 
-		var header = this.parseHeader( data );
+				body = result [ 1 ];
 
-		var patternBody = /end_header\s([\s\S]*)$/;
-		var body = "";
-		if ( ( result = patternBody.exec( data ) ) !== null ) {
+			}
 
-			body = result [ 1 ];
+			var lines = body.split( '\n' );
+			var currentElement = 0;
+			var currentElementCount = 0;
+			geometry.useColor = false;
 
-		}
+			for ( var i = 0; i < lines.length; i ++ ) {
 
-		var lines = body.split( '\n' );
-		var currentElement = 0;
-		var currentElementCount = 0;
-		geometry.useColor = false;
+				var line = lines[ i ];
+				line = line.trim();
+				if ( line === "" ) {
 
-		for ( var i = 0; i < lines.length; i ++ ) {
+					continue;
 
-			var line = lines[ i ];
-			line = line.trim();
-			if ( line === "" ) {
+				}
 
-				continue;
+				if ( currentElementCount >= header.elements[ currentElement ].count ) {
 
-			}
+					currentElement ++;
+					currentElementCount = 0;
 
-			if ( currentElementCount >= header.elements[ currentElement ].count ) {
+				}
 
-				currentElement ++;
-				currentElementCount = 0;
+				var element = parseASCIIElement( header.elements[ currentElement ].properties, line );
 
-			}
+				handleElement( geometry, header.elements[ currentElement ].name, element );
 
-			var element = this.parseASCIIElement( header.elements[ currentElement ].properties, line );
+				currentElementCount ++;
 
-			this.handleElement( geometry, header.elements[ currentElement ].name, element );
+			}
 
-			currentElementCount ++;
+			return postProcess( geometry );
 
 		}
 
-		return this.postProcess( geometry );
+		function postProcess( geometry ) {
 
-	},
+			if ( geometry.useColor ) {
 
-	postProcess: function ( geometry ) {
+				for ( var i = 0; i < geometry.faces.length; i ++ ) {
 
-		if ( geometry.useColor ) {
+					geometry.faces[ i ].vertexColors = [
+						geometry.colors[ geometry.faces[ i ].a ],
+						geometry.colors[ geometry.faces[ i ].b ],
+						geometry.colors[ geometry.faces[ i ].c ]
+					];
 
-			for ( var i = 0; i < geometry.faces.length; i ++ ) {
+				}
 
-				geometry.faces[ i ].vertexColors = [
-					geometry.colors[ geometry.faces[ i ].a ],
-					geometry.colors[ geometry.faces[ i ].b ],
-					geometry.colors[ geometry.faces[ i ].c ]
-				];
+				geometry.elementsNeedUpdate = true;
 
 			}
 
-			geometry.elementsNeedUpdate = true;
-
-		}
+			geometry.computeBoundingSphere();
 
-		geometry.computeBoundingSphere();
+			return geometry;
 
-		return geometry;
+		}
 
-	},
+		function handleElement( geometry, elementName, element ) {
 
-	handleElement: function ( geometry, elementName, element ) {
+			if ( elementName === "vertex" ) {
 
-		if ( elementName === "vertex" ) {
+				geometry.vertices.push(
+					new THREE.Vector3( element.x, element.y, element.z )
+				);
 
-			geometry.vertices.push(
-				new THREE.Vector3( element.x, element.y, element.z )
-			);
+				if ( 'red' in element && 'green' in element && 'blue' in element ) {
 
-			if ( 'red' in element && 'green' in element && 'blue' in element ) {
+					geometry.useColor = true;
 
-				geometry.useColor = true;
+					var color = new THREE.Color();
+					color.setRGB( element.red / 255.0, element.green / 255.0, element.blue / 255.0 );
+					geometry.colors.push( color );
 
-				var color = new THREE.Color();
-				color.setRGB( element.red / 255.0, element.green / 255.0, element.blue / 255.0 );
-				geometry.colors.push( color );
+				}
 
-			}
+			} else if ( elementName === "face" ) {
 
-		} else if ( elementName === "face" ) {
+				var vertex_indices = element.vertex_indices;
 
-			var vertex_indices = element.vertex_indices;
+				if ( vertex_indices.length === 3 ) {
 
-			if ( vertex_indices.length === 3 ) {
+					geometry.faces.push(
+						new THREE.Face3( vertex_indices[ 0 ], vertex_indices[ 1 ], vertex_indices[ 2 ] )
+					);
 
-				geometry.faces.push(
-					new THREE.Face3( vertex_indices[ 0 ], vertex_indices[ 1 ], vertex_indices[ 2 ] )
-				);
+				} else if ( vertex_indices.length === 4 ) {
 
-			} else if ( vertex_indices.length === 4 ) {
+					geometry.faces.push(
+						new THREE.Face3( vertex_indices[ 0 ], vertex_indices[ 1 ], vertex_indices[ 3 ] ),
+						new THREE.Face3( vertex_indices[ 1 ], vertex_indices[ 2 ], vertex_indices[ 3 ] )
+					);
 
-				geometry.faces.push(
-					new THREE.Face3( vertex_indices[ 0 ], vertex_indices[ 1 ], vertex_indices[ 3 ] ),
-					new THREE.Face3( vertex_indices[ 1 ], vertex_indices[ 2 ], vertex_indices[ 3 ] )
-				);
+				}
 
 			}
 
 		}
 
-	},
+		function binaryRead( dataview, at, type, little_endian ) {
 
-	binaryRead: function ( dataview, at, type, little_endian ) {
+			switch ( type ) {
 
-		switch ( type ) {
+				// corespondences for non-specific length types here match rply:
+				case 'int8':		case 'char':	 return [ dataview.getInt8( at ), 1 ];
+				case 'uint8':		case 'uchar':	 return [ dataview.getUint8( at ), 1 ];
+				case 'int16':		case 'short':	 return [ dataview.getInt16( at, little_endian ), 2 ];
+				case 'uint16':	case 'ushort': return [ dataview.getUint16( at, little_endian ), 2 ];
+				case 'int32':		case 'int':		 return [ dataview.getInt32( at, little_endian ), 4 ];
+				case 'uint32':	case 'uint':	 return [ dataview.getUint32( at, little_endian ), 4 ];
+				case 'float32': case 'float':	 return [ dataview.getFloat32( at, little_endian ), 4 ];
+				case 'float64': case 'double': return [ dataview.getFloat64( at, little_endian ), 8 ];
 
-			// corespondences for non-specific length types here match rply:
-		case 'int8':		case 'char':	 return [ dataview.getInt8( at ), 1 ];
+			}
 
-		case 'uint8':		case 'uchar':	 return [ dataview.getUint8( at ), 1 ];
+		}
 
-		case 'int16':		case 'short':	 return [ dataview.getInt16( at, little_endian ), 2 ];
+		function binaryReadElement( dataview, at, properties, little_endian ) {
 
-		case 'uint16':	case 'ushort': return [ dataview.getUint16( at, little_endian ), 2 ];
+			var element = {};
+			var result, read = 0;
 
-		case 'int32':		case 'int':		 return [ dataview.getInt32( at, little_endian ), 4 ];
+			for ( var i = 0; i < properties.length; i ++ ) {
 
-		case 'uint32':	case 'uint':	 return [ dataview.getUint32( at, little_endian ), 4 ];
+				if ( properties[ i ].type === "list" ) {
 
-		case 'float32': case 'float':	 return [ dataview.getFloat32( at, little_endian ), 4 ];
+					var list = [];
 
-		case 'float64': case 'double': return [ dataview.getFloat64( at, little_endian ), 8 ];
+					result = binaryRead( dataview, at + read, properties[ i ].countType, little_endian );
+					var n = result[ 0 ];
+					read += result[ 1 ];
 
-		}
+					for ( var j = 0; j < n; j ++ ) {
 
-	},
+						result = binaryRead( dataview, at + read, properties[ i ].itemType, little_endian );
+						list.push( result[ 0 ] );
+						read += result[ 1 ];
 
-	binaryReadElement: function ( dataview, at, properties, little_endian ) {
+					}
 
-		var element = Object();
-		var result, read = 0;
+					element[ properties[ i ].name ] = list;
 
-		for ( var i = 0; i < properties.length; i ++ ) {
+				} else {
 
-			if ( properties[ i ].type === "list" ) {
+					result = binaryRead( dataview, at + read, properties[ i ].type, little_endian );
+					element[ properties[ i ].name ] = result[ 0 ];
+					read += result[ 1 ];
 
-				var list = [];
+				}
 
-				result = this.binaryRead( dataview, at + read, properties[ i ].countType, little_endian );
-				var n = result[ 0 ];
-				read += result[ 1 ];
+			}
 
-				for ( var j = 0; j < n; j ++ ) {
+			return [ element, read ];
 
-					result = this.binaryRead( dataview, at + read, properties[ i ].itemType, little_endian );
-					list.push( result[ 0 ] );
-					read += result[ 1 ];
+		}
 
-				}
+		function parseBinary( data ) {
 
-				element[ properties[ i ].name ] = list;
+			var geometry = new THREE.Geometry();
 
-			} else {
+			var header = parseHeader( bin2str( data ) );
+			var little_endian = ( header.format === "binary_little_endian" );
+			var body = new DataView( data, header.headerLength );
+			var result, loc = 0;
 
-				result = this.binaryRead( dataview, at + read, properties[ i ].type, little_endian );
-				element[ properties[ i ].name ] = result[ 0 ];
-				read += result[ 1 ];
+			for ( var currentElement = 0; currentElement < header.elements.length; currentElement ++ ) {
 
-			}
+				for ( var currentElementCount = 0; currentElementCount < header.elements[ currentElement ].count; currentElementCount ++ ) {
 
-		}
+					result = binaryReadElement( body, loc, header.elements[ currentElement ].properties, little_endian );
+					loc += result[ 1 ];
+					var element = result[ 0 ];
 
-		return [ element, read ];
+					handleElement( geometry, header.elements[ currentElement ].name, element );
 
-	},
+				}
 
-	parseBinary: function ( data ) {
+			}
 
-		var geometry = new THREE.Geometry();
+			return postProcess( geometry );
 
-		var header = this.parseHeader( this.bin2str( data ) );
-		var little_endian = ( header.format === "binary_little_endian" );
-		var body = new DataView( data, header.headerLength );
-		var result, loc = 0;
+		}
 
-		for ( var currentElement = 0; currentElement < header.elements.length; currentElement ++ ) {
+		//
 
-			for ( var currentElementCount = 0; currentElementCount < header.elements[ currentElement ].count; currentElementCount ++ ) {
+		console.time( 'PLYLoader' );
 
-				result = this.binaryReadElement( body, loc, header.elements[ currentElement ].properties, little_endian );
-				loc += result[ 1 ];
-				var element = result[ 0 ];
+		var geometry;
+		var scope = this;
 
-				this.handleElement( geometry, header.elements[ currentElement ].name, element );
+		if ( data instanceof ArrayBuffer ) {
 
-			}
+			geometry = isASCII( data ) ? parseASCII( bin2str( data ) ) : parseBinary( data );
+
+		} else {
+
+			geometry = parseASCII( data );
 
 		}
 
-		return this.postProcess( geometry );
+		console.timeEnd( 'PLYLoader' );
+
+		return geometry;
 
 	}