@needle-tools/three 0.145.0

package/examples/js/loaders/PCDLoader.js

@@ -0,0 +1,408 @@
+( function () {
+
+	class PCDLoader extends THREE.Loader {
+
+		constructor( manager ) {
+
+			super( manager );
+			this.littleEndian = true;
+
+		}
+
+		load( url, onLoad, onProgress, onError ) {
+
+			const scope = this;
+			const loader = new THREE.FileLoader( scope.manager );
+			loader.setPath( scope.path );
+			loader.setResponseType( 'arraybuffer' );
+			loader.setRequestHeader( scope.requestHeader );
+			loader.setWithCredentials( scope.withCredentials );
+			loader.load( url, function ( data ) {
+
+				try {
+
+					onLoad( scope.parse( data ) );
+
+				} catch ( e ) {
+
+					if ( onError ) {
+
+						onError( e );
+
+					} else {
+
+						console.error( e );
+
+					}
+
+					scope.manager.itemError( url );
+
+				}
+
+			}, onProgress, onError );
+
+		}
+
+		parse( data ) {
+
+			// from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js
+			function decompressLZF( inData, outLength ) {
+
+				const inLength = inData.length;
+				const outData = new Uint8Array( outLength );
+				let inPtr = 0;
+				let outPtr = 0;
+				let ctrl;
+				let len;
+				let ref;
+
+				do {
+
+					ctrl = inData[ inPtr ++ ];
+
+					if ( ctrl < 1 << 5 ) {
+
+						ctrl ++;
+						if ( outPtr + ctrl > outLength ) throw new Error( 'Output buffer is not large enough' );
+						if ( inPtr + ctrl > inLength ) throw new Error( 'Invalid compressed data' );
+
+						do {
+
+							outData[ outPtr ++ ] = inData[ inPtr ++ ];
+
+						} while ( -- ctrl );
+
+					} else {
+
+						len = ctrl >> 5;
+						ref = outPtr - ( ( ctrl & 0x1f ) << 8 ) - 1;
+						if ( inPtr >= inLength ) throw new Error( 'Invalid compressed data' );
+
+						if ( len === 7 ) {
+
+							len += inData[ inPtr ++ ];
+							if ( inPtr >= inLength ) throw new Error( 'Invalid compressed data' );
+
+						}
+
+						ref -= inData[ inPtr ++ ];
+						if ( outPtr + len + 2 > outLength ) throw new Error( 'Output buffer is not large enough' );
+						if ( ref < 0 ) throw new Error( 'Invalid compressed data' );
+						if ( ref >= outPtr ) throw new Error( 'Invalid compressed data' );
+
+						do {
+
+							outData[ outPtr ++ ] = outData[ ref ++ ];
+
+						} while ( -- len + 2 );
+
+					}
+
+				} while ( inPtr < inLength );
+
+				return outData;
+
+			}
+
+			function parseHeader( data ) {
+
+				const PCDheader = {};
+				const result1 = data.search( /[\r\n]DATA\s(\S*)\s/i );
+				const result2 = /[\r\n]DATA\s(\S*)\s/i.exec( data.slice( result1 - 1 ) );
+				PCDheader.data = result2[ 1 ];
+				PCDheader.headerLen = result2[ 0 ].length + result1;
+				PCDheader.str = data.slice( 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 ] );
+				PCDheader.fields = PCDheader.fields !== null ? 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 ( let i = 0, l = PCDheader.fields.length; i < l; i ++ ) {
+
+						PCDheader.count.push( 1 );
+
+					}
+
+				}
+
+				PCDheader.offset = {};
+				let sizeSum = 0;
+
+				for ( let 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 ] * PCDheader.count[ i ];
+
+					}
+
+				} // for binary only
+
+
+				PCDheader.rowSize = sizeSum;
+				return PCDheader;
+
+			}
+
+			const textData = THREE.LoaderUtils.decodeText( new Uint8Array( data ) ); // parse header (always ascii format)
+
+			const PCDheader = parseHeader( textData ); // parse data
+
+			const position = [];
+			const normal = [];
+			const color = [];
+			const intensity = [];
+			const label = []; // ascii
+
+			if ( PCDheader.data === 'ascii' ) {
+
+				const offset = PCDheader.offset;
+				const pcdData = textData.slice( PCDheader.headerLen );
+				const lines = pcdData.split( '\n' );
+
+				for ( let i = 0, l = lines.length; i < l; i ++ ) {
+
+					if ( lines[ i ] === '' ) continue;
+					const 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 ) {
+
+						const rgb_field_index = PCDheader.fields.findIndex( field => field === 'rgb' );
+						const rgb_type = PCDheader.type[ rgb_field_index ];
+						const float = parseFloat( line[ offset.rgb ] );
+						let rgb = float;
+
+						if ( rgb_type === 'F' ) {
+
+							// treat float values as int
+							// https://github.com/daavoo/pyntcloud/pull/204/commits/7b4205e64d5ed09abe708b2e91b615690c24d518
+							const farr = new Float32Array( 1 );
+							farr[ 0 ] = float;
+							rgb = new Int32Array( farr.buffer )[ 0 ];
+
+						}
+
+						const r = rgb >> 16 & 0x0000ff;
+						const g = rgb >> 8 & 0x0000ff;
+						const b = rgb >> 0 & 0x0000ff;
+						color.push( r / 255, g / 255, b / 255 );
+
+					}
+
+					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 ] ) );
+
+					}
+
+					if ( offset.intensity !== undefined ) {
+
+						intensity.push( parseFloat( line[ offset.intensity ] ) );
+
+					}
+
+					if ( offset.label !== undefined ) {
+
+						label.push( parseInt( line[ offset.label ] ) );
+
+					}
+
+				}
+
+			} // binary-compressed
+			// normally data in PCD files are organized as array of structures: XYZRGBXYZRGB
+			// binary compressed PCD files organize their data as structure of arrays: XXYYZZRGBRGB
+			// that requires a totally different parsing approach compared to non-compressed data
+
+
+			if ( PCDheader.data === 'binary_compressed' ) {
+
+				const sizes = new Uint32Array( data.slice( PCDheader.headerLen, PCDheader.headerLen + 8 ) );
+				const compressedSize = sizes[ 0 ];
+				const decompressedSize = sizes[ 1 ];
+				const decompressed = decompressLZF( new Uint8Array( data, PCDheader.headerLen + 8, compressedSize ), decompressedSize );
+				const dataview = new DataView( decompressed.buffer );
+				const offset = PCDheader.offset;
+
+				for ( let i = 0; i < PCDheader.points; i ++ ) {
+
+					if ( offset.x !== undefined ) {
+
+						const xIndex = PCDheader.fields.indexOf( 'x' );
+						const yIndex = PCDheader.fields.indexOf( 'y' );
+						const zIndex = PCDheader.fields.indexOf( 'z' );
+						position.push( dataview.getFloat32( PCDheader.points * offset.x + PCDheader.size[ xIndex ] * i, this.littleEndian ) );
+						position.push( dataview.getFloat32( PCDheader.points * offset.y + PCDheader.size[ yIndex ] * i, this.littleEndian ) );
+						position.push( dataview.getFloat32( PCDheader.points * offset.z + PCDheader.size[ zIndex ] * i, this.littleEndian ) );
+
+					}
+
+					if ( offset.rgb !== undefined ) {
+
+						const rgbIndex = PCDheader.fields.indexOf( 'rgb' );
+						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ rgbIndex ] * i + 2 ) / 255.0 );
+						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ rgbIndex ] * i + 1 ) / 255.0 );
+						color.push( dataview.getUint8( PCDheader.points * offset.rgb + PCDheader.size[ rgbIndex ] * i + 0 ) / 255.0 );
+
+					}
+
+					if ( offset.normal_x !== undefined ) {
+
+						const xIndex = PCDheader.fields.indexOf( 'normal_x' );
+						const yIndex = PCDheader.fields.indexOf( 'normal_y' );
+						const zIndex = PCDheader.fields.indexOf( 'normal_z' );
+						normal.push( dataview.getFloat32( PCDheader.points * offset.normal_x + PCDheader.size[ xIndex ] * i, this.littleEndian ) );
+						normal.push( dataview.getFloat32( PCDheader.points * offset.normal_y + PCDheader.size[ yIndex ] * i, this.littleEndian ) );
+						normal.push( dataview.getFloat32( PCDheader.points * offset.normal_z + PCDheader.size[ zIndex ] * i, this.littleEndian ) );
+
+					}
+
+					if ( offset.intensity !== undefined ) {
+
+						const intensityIndex = PCDheader.fields.indexOf( 'intensity' );
+						intensity.push( dataview.getFloat32( PCDheader.points * offset.intensity + PCDheader.size[ intensityIndex ] * i, this.littleEndian ) );
+
+					}
+
+					if ( offset.label !== undefined ) {
+
+						const labelIndex = PCDheader.fields.indexOf( 'label' );
+						label.push( dataview.getInt32( PCDheader.points * offset.label + PCDheader.size[ labelIndex ] * i, this.littleEndian ) );
+
+					}
+
+				}
+
+			} // binary
+
+
+			if ( PCDheader.data === 'binary' ) {
+
+				const dataview = new DataView( data, PCDheader.headerLen );
+				const offset = PCDheader.offset;
+
+				for ( let 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 + 2 ) / 255.0 );
+						color.push( dataview.getUint8( row + offset.rgb + 1 ) / 255.0 );
+						color.push( dataview.getUint8( row + offset.rgb + 0 ) / 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 ) );
+
+					}
+
+					if ( offset.intensity !== undefined ) {
+
+						intensity.push( dataview.getFloat32( row + offset.intensity, this.littleEndian ) );
+
+					}
+
+					if ( offset.label !== undefined ) {
+
+						label.push( dataview.getInt32( row + offset.label, this.littleEndian ) );
+
+					}
+
+				}
+
+			} // build geometry
+
+
+			const geometry = new THREE.BufferGeometry();
+			if ( position.length > 0 ) geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( position, 3 ) );
+			if ( normal.length > 0 ) geometry.setAttribute( 'normal', new THREE.Float32BufferAttribute( normal, 3 ) );
+			if ( color.length > 0 ) geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( color, 3 ) );
+			if ( intensity.length > 0 ) geometry.setAttribute( 'intensity', new THREE.Float32BufferAttribute( intensity, 1 ) );
+			if ( label.length > 0 ) geometry.setAttribute( 'label', new THREE.Int32BufferAttribute( label, 1 ) );
+			geometry.computeBoundingSphere(); // build material
+
+			const material = new THREE.PointsMaterial( {
+				size: 0.005
+			} );
+
+			if ( color.length > 0 ) {
+
+				material.vertexColors = true;
+
+			} // build point cloud
+
+
+			return new THREE.Points( geometry, material );
+
+		}
+
+	}
+
+	THREE.PCDLoader = PCDLoader;
+
+} )();

package/examples/js/loaders/PDBLoader.js

@@ -0,0 +1,313 @@
+( function () {
+
+	class PDBLoader extends THREE.Loader {
+
+		constructor( manager ) {
+
+			super( manager );
+
+		}
+
+		load( url, onLoad, onProgress, onError ) {
+
+			const scope = this;
+			const loader = new THREE.FileLoader( scope.manager );
+			loader.setPath( scope.path );
+			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 );
+
+		} // Based on CanvasMol PDB parser
+
+
+		parse( text ) {
+
+			function trim( text ) {
+
+				return text.replace( /^\s\s*/, '' ).replace( /\s\s*$/, '' );
+
+			}
+
+			function capitalize( text ) {
+
+				return text.charAt( 0 ).toUpperCase() + text.slice( 1 ).toLowerCase();
+
+			}
+
+			function hash( s, e ) {
+
+				return 's' + Math.min( s, e ) + 'e' + Math.max( s, e );
+
+			}
+
+			function parseBond( start, length, satom, i ) {
+
+				const eatom = parseInt( lines[ i ].slice( start, start + length ) );
+
+				if ( eatom ) {
+
+					const h = hash( satom, eatom );
+
+					if ( _bhash[ h ] === undefined ) {
+
+						_bonds.push( [ satom - 1, eatom - 1, 1 ] );
+
+						_bhash[ h ] = _bonds.length - 1;
+
+					} else { // doesn't really work as almost all PDBs
+						// have just normal bonds appearing multiple
+						// times instead of being double/triple bonds
+						// bonds[bhash[h]][2] += 1;
+					}
+
+				}
+
+			}
+
+			function buildGeometry() {
+
+				const build = {
+					geometryAtoms: new THREE.BufferGeometry(),
+					geometryBonds: new THREE.BufferGeometry(),
+					json: {
+						atoms: atoms
+					}
+				};
+				const geometryAtoms = build.geometryAtoms;
+				const geometryBonds = build.geometryBonds;
+				const verticesAtoms = [];
+				const colorsAtoms = [];
+				const verticesBonds = []; // atoms
+
+				for ( let i = 0, l = atoms.length; i < l; i ++ ) {
+
+					const atom = atoms[ i ];
+					const x = atom[ 0 ];
+					const y = atom[ 1 ];
+					const z = atom[ 2 ];
+					verticesAtoms.push( x, y, z );
+					const r = atom[ 3 ][ 0 ] / 255;
+					const g = atom[ 3 ][ 1 ] / 255;
+					const b = atom[ 3 ][ 2 ] / 255;
+					colorsAtoms.push( r, g, b );
+
+				} // bonds
+
+
+				for ( let i = 0, l = _bonds.length; i < l; i ++ ) {
+
+					const bond = _bonds[ i ];
+					const start = bond[ 0 ];
+					const end = bond[ 1 ];
+					const startAtom = _atomMap[ start ];
+					const endAtom = _atomMap[ end ];
+					let x = startAtom[ 0 ];
+					let y = startAtom[ 1 ];
+					let z = startAtom[ 2 ];
+					verticesBonds.push( x, y, z );
+					x = endAtom[ 0 ];
+					y = endAtom[ 1 ];
+					z = endAtom[ 2 ];
+					verticesBonds.push( x, y, z );
+
+				} // build geometry
+
+
+				geometryAtoms.setAttribute( 'position', new THREE.Float32BufferAttribute( verticesAtoms, 3 ) );
+				geometryAtoms.setAttribute( 'color', new THREE.Float32BufferAttribute( colorsAtoms, 3 ) );
+				geometryBonds.setAttribute( 'position', new THREE.Float32BufferAttribute( verticesBonds, 3 ) );
+				return build;
+
+			}
+
+			const CPK = {
+				h: [ 255, 255, 255 ],
+				he: [ 217, 255, 255 ],
+				li: [ 204, 128, 255 ],
+				be: [ 194, 255, 0 ],
+				b: [ 255, 181, 181 ],
+				c: [ 144, 144, 144 ],
+				n: [ 48, 80, 248 ],
+				o: [ 255, 13, 13 ],
+				f: [ 144, 224, 80 ],
+				ne: [ 179, 227, 245 ],
+				na: [ 171, 92, 242 ],
+				mg: [ 138, 255, 0 ],
+				al: [ 191, 166, 166 ],
+				si: [ 240, 200, 160 ],
+				p: [ 255, 128, 0 ],
+				s: [ 255, 255, 48 ],
+				cl: [ 31, 240, 31 ],
+				ar: [ 128, 209, 227 ],
+				k: [ 143, 64, 212 ],
+				ca: [ 61, 255, 0 ],
+				sc: [ 230, 230, 230 ],
+				ti: [ 191, 194, 199 ],
+				v: [ 166, 166, 171 ],
+				cr: [ 138, 153, 199 ],
+				mn: [ 156, 122, 199 ],
+				fe: [ 224, 102, 51 ],
+				co: [ 240, 144, 160 ],
+				ni: [ 80, 208, 80 ],
+				cu: [ 200, 128, 51 ],
+				zn: [ 125, 128, 176 ],
+				ga: [ 194, 143, 143 ],
+				ge: [ 102, 143, 143 ],
+				as: [ 189, 128, 227 ],
+				se: [ 255, 161, 0 ],
+				br: [ 166, 41, 41 ],
+				kr: [ 92, 184, 209 ],
+				rb: [ 112, 46, 176 ],
+				sr: [ 0, 255, 0 ],
+				y: [ 148, 255, 255 ],
+				zr: [ 148, 224, 224 ],
+				nb: [ 115, 194, 201 ],
+				mo: [ 84, 181, 181 ],
+				tc: [ 59, 158, 158 ],
+				ru: [ 36, 143, 143 ],
+				rh: [ 10, 125, 140 ],
+				pd: [ 0, 105, 133 ],
+				ag: [ 192, 192, 192 ],
+				cd: [ 255, 217, 143 ],
+				in: [ 166, 117, 115 ],
+				sn: [ 102, 128, 128 ],
+				sb: [ 158, 99, 181 ],
+				te: [ 212, 122, 0 ],
+				i: [ 148, 0, 148 ],
+				xe: [ 66, 158, 176 ],
+				cs: [ 87, 23, 143 ],
+				ba: [ 0, 201, 0 ],
+				la: [ 112, 212, 255 ],
+				ce: [ 255, 255, 199 ],
+				pr: [ 217, 255, 199 ],
+				nd: [ 199, 255, 199 ],
+				pm: [ 163, 255, 199 ],
+				sm: [ 143, 255, 199 ],
+				eu: [ 97, 255, 199 ],
+				gd: [ 69, 255, 199 ],
+				tb: [ 48, 255, 199 ],
+				dy: [ 31, 255, 199 ],
+				ho: [ 0, 255, 156 ],
+				er: [ 0, 230, 117 ],
+				tm: [ 0, 212, 82 ],
+				yb: [ 0, 191, 56 ],
+				lu: [ 0, 171, 36 ],
+				hf: [ 77, 194, 255 ],
+				ta: [ 77, 166, 255 ],
+				w: [ 33, 148, 214 ],
+				re: [ 38, 125, 171 ],
+				os: [ 38, 102, 150 ],
+				ir: [ 23, 84, 135 ],
+				pt: [ 208, 208, 224 ],
+				au: [ 255, 209, 35 ],
+				hg: [ 184, 184, 208 ],
+				tl: [ 166, 84, 77 ],
+				pb: [ 87, 89, 97 ],
+				bi: [ 158, 79, 181 ],
+				po: [ 171, 92, 0 ],
+				at: [ 117, 79, 69 ],
+				rn: [ 66, 130, 150 ],
+				fr: [ 66, 0, 102 ],
+				ra: [ 0, 125, 0 ],
+				ac: [ 112, 171, 250 ],
+				th: [ 0, 186, 255 ],
+				pa: [ 0, 161, 255 ],
+				u: [ 0, 143, 255 ],
+				np: [ 0, 128, 255 ],
+				pu: [ 0, 107, 255 ],
+				am: [ 84, 92, 242 ],
+				cm: [ 120, 92, 227 ],
+				bk: [ 138, 79, 227 ],
+				cf: [ 161, 54, 212 ],
+				es: [ 179, 31, 212 ],
+				fm: [ 179, 31, 186 ],
+				md: [ 179, 13, 166 ],
+				no: [ 189, 13, 135 ],
+				lr: [ 199, 0, 102 ],
+				rf: [ 204, 0, 89 ],
+				db: [ 209, 0, 79 ],
+				sg: [ 217, 0, 69 ],
+				bh: [ 224, 0, 56 ],
+				hs: [ 230, 0, 46 ],
+				mt: [ 235, 0, 38 ],
+				ds: [ 235, 0, 38 ],
+				rg: [ 235, 0, 38 ],
+				cn: [ 235, 0, 38 ],
+				uut: [ 235, 0, 38 ],
+				uuq: [ 235, 0, 38 ],
+				uup: [ 235, 0, 38 ],
+				uuh: [ 235, 0, 38 ],
+				uus: [ 235, 0, 38 ],
+				uuo: [ 235, 0, 38 ]
+			};
+			const atoms = [];
+			const _bonds = [];
+			const _bhash = {};
+			const _atomMap = {}; // parse
+
+			const lines = text.split( '\n' );
+
+			for ( let i = 0, l = lines.length; i < l; i ++ ) {
+
+				if ( lines[ i ].slice( 0, 4 ) === 'ATOM' || lines[ i ].slice( 0, 6 ) === 'HETATM' ) {
+
+					const x = parseFloat( lines[ i ].slice( 30, 37 ) );
+					const y = parseFloat( lines[ i ].slice( 38, 45 ) );
+					const z = parseFloat( lines[ i ].slice( 46, 53 ) );
+					const index = parseInt( lines[ i ].slice( 6, 11 ) ) - 1;
+					let e = trim( lines[ i ].slice( 76, 78 ) ).toLowerCase();
+
+					if ( e === '' ) {
+
+						e = trim( lines[ i ].slice( 12, 14 ) ).toLowerCase();
+
+					}
+
+					const atomData = [ x, y, z, CPK[ e ], capitalize( e ) ];
+					atoms.push( atomData );
+					_atomMap[ index ] = atomData;
+
+				} else if ( lines[ i ].slice( 0, 6 ) === 'CONECT' ) {
+
+					const satom = parseInt( lines[ i ].slice( 6, 11 ) );
+					parseBond( 11, 5, satom, i );
+					parseBond( 16, 5, satom, i );
+					parseBond( 21, 5, satom, i );
+					parseBond( 26, 5, satom, i );
+
+				}
+
+			} // build and return geometry
+
+
+			return buildGeometry();
+
+		}
+
+	}
+
+	THREE.PDBLoader = PDBLoader;
+
+} )();