Dies ist das Repository meines kleinen Portfolios.
Im Hintergrund läuft eine Planetensimulation, geschrieben in JavaScript und Three.js.
Die zu sehenden Texturen stammen von:
https://www.solarsystemscope.com/textures/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1130 lines
27 KiB
1130 lines
27 KiB
( function () { |
|
|
|
class VTKLoader 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.setResponseType( 'arraybuffer' ); |
|
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 ); |
|
|
|
} |
|
|
|
parse( 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 detecting the end of a number sequence |
|
|
|
var patWord = /^[^\d.\s-]+/; // 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 ].trim(); |
|
|
|
if ( line.indexOf( 'DATASET' ) === 0 ) { |
|
|
|
var dataset = line.split( ' ' )[ 1 ]; |
|
if ( dataset !== 'POLYDATA' ) throw new Error( 'Unsupported DATASET type: ' + dataset ); |
|
|
|
} else if ( inPointsSection ) { |
|
|
|
// get the vertices |
|
while ( ( result = pat3Floats.exec( line ) ) !== null ) { |
|
|
|
if ( patWord.exec( line ) !== null ) break; |
|
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 ) { |
|
|
|
if ( patWord.exec( line ) !== null ) break; |
|
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 ) { |
|
|
|
if ( patWord.exec( line ) !== null ) break; |
|
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 = new THREE.BufferGeometry(); |
|
geometry.setIndex( indices ); |
|
geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( positions, 3 ) ); |
|
|
|
if ( normals.length === positions.length ) { |
|
|
|
geometry.setAttribute( 'normal', new THREE.Float32BufferAttribute( normals, 3 ) ); |
|
|
|
} |
|
|
|
if ( colors.length !== indices.length ) { |
|
|
|
// stagger |
|
if ( colors.length === positions.length ) { |
|
|
|
geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( colors, 3 ) ); |
|
|
|
} |
|
|
|
} else { |
|
|
|
// cell |
|
geometry = geometry.toNonIndexed(); |
|
var numTriangles = geometry.attributes.position.count / 3; |
|
|
|
if ( colors.length === numTriangles * 3 ) { |
|
|
|
var newColors = []; |
|
|
|
for ( var i = 0; i < numTriangles; i ++ ) { |
|
|
|
var r = colors[ 3 * i + 0 ]; |
|
var g = colors[ 3 * i + 1 ]; |
|
var b = colors[ 3 * i + 2 ]; |
|
newColors.push( r, g, b ); |
|
newColors.push( r, g, b ); |
|
newColors.push( r, g, b ); |
|
|
|
} |
|
|
|
geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( newColors, 3 ) ); |
|
|
|
} |
|
|
|
} |
|
|
|
return geometry; |
|
|
|
} |
|
|
|
function parseBinary( data ) { |
|
|
|
var count, pointIndex, i, numberOfPoints, 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( 'DATASET' ) === 0 ) { |
|
|
|
var dataset = line.split( ' ' )[ 1 ]; |
|
if ( dataset !== 'POLYDATA' ) throw new Error( 'Unsupported DATASET type: ' + dataset ); |
|
|
|
} else 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; |
|
|
|
} // 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.setAttribute( 'position', new THREE.BufferAttribute( points, 3 ) ); |
|
|
|
if ( normals.length === points.length ) { |
|
|
|
geometry.setAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) ); |
|
|
|
} |
|
|
|
return geometry; |
|
|
|
} |
|
|
|
function Float32Concat( first, second ) { |
|
|
|
const firstLength = first.length, |
|
result = new Float32Array( firstLength + second.length ); |
|
result.set( first ); |
|
result.set( second, firstLength ); |
|
return result; |
|
|
|
} |
|
|
|
function Int32Concat( first, second ) { |
|
|
|
var firstLength = first.length, |
|
result = new Int32Array( firstLength + second.length ); |
|
result.set( first ); |
|
result.set( second, firstLength ); |
|
return result; |
|
|
|
} |
|
|
|
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 ) { |
|
|
|
var numBytes = 0; |
|
|
|
if ( json.attributes.header_type === 'UInt64' ) { |
|
|
|
numBytes = 8; |
|
|
|
} else if ( json.attributes.header_type === 'UInt32' ) { |
|
|
|
numBytes = 4; |
|
|
|
} // Check the format |
|
|
|
|
|
if ( ele.attributes.format === 'binary' && compressed ) { |
|
|
|
var rawData, content, byteData, blocks, cSizeStart, headerSize, padding, dataOffsets, currentOffset; |
|
|
|
if ( ele.attributes.type === 'Float32' ) { |
|
|
|
var txt = new Float32Array(); |
|
|
|
} else if ( ele.attributes.type === 'Int64' ) { |
|
|
|
var txt = new Int32Array(); |
|
|
|
} // VTP data with the header has the following structure: |
|
// [#blocks][#u-size][#p-size][#c-size-1][#c-size-2]...[#c-size-#blocks][DATA] |
|
// |
|
// Each token is an integer value whose type is specified by "header_type" at the top of the file (UInt32 if no type specified). The token meanings are: |
|
// [#blocks] = Number of blocks |
|
// [#u-size] = Block size before compression |
|
// [#p-size] = Size of last partial block (zero if it not needed) |
|
// [#c-size-i] = Size in bytes of block i after compression |
|
// |
|
// The [DATA] portion stores contiguously every block appended together. The offset from the beginning of the data section to the beginning of a block is |
|
// computed by summing the compressed block sizes from preceding blocks according to the header. |
|
|
|
|
|
rawData = ele[ '#text' ]; |
|
byteData = Base64toByteArray( rawData ); |
|
blocks = byteData[ 0 ]; |
|
|
|
for ( var i = 1; i < numBytes - 1; i ++ ) { |
|
|
|
blocks = blocks | byteData[ i ] << i * numBytes; |
|
|
|
} |
|
|
|
headerSize = ( blocks + 3 ) * numBytes; |
|
padding = headerSize % 3 > 0 ? 3 - headerSize % 3 : 0; |
|
headerSize = headerSize + padding; |
|
dataOffsets = []; |
|
currentOffset = headerSize; |
|
dataOffsets.push( currentOffset ); // Get the blocks sizes after the compression. |
|
// There are three blocks before c-size-i, so we skip 3*numBytes |
|
|
|
cSizeStart = 3 * numBytes; |
|
|
|
for ( var i = 0; i < blocks; i ++ ) { |
|
|
|
var currentBlockSize = byteData[ i * numBytes + cSizeStart ]; |
|
|
|
for ( var j = 1; j < numBytes - 1; j ++ ) { |
|
|
|
// Each data point consists of 8 bytes regardless of the header type |
|
currentBlockSize = currentBlockSize | byteData[ i * numBytes + cSizeStart + j ] << j * 8; |
|
|
|
} |
|
|
|
currentOffset = currentOffset + currentBlockSize; |
|
dataOffsets.push( currentOffset ); |
|
|
|
} |
|
|
|
for ( var i = 0; i < dataOffsets.length - 1; i ++ ) { |
|
|
|
var data = fflate.unzlibSync( byteData.slice( dataOffsets[ i ], dataOffsets[ i + 1 ] ) ); // eslint-disable-line no-undef |
|
|
|
content = data.buffer; |
|
|
|
if ( ele.attributes.type === 'Float32' ) { |
|
|
|
content = new Float32Array( content ); |
|
txt = Float32Concat( txt, content ); |
|
|
|
} else if ( ele.attributes.type === 'Int64' ) { |
|
|
|
content = new Int32Array( content ); |
|
txt = Int32Concat( txt, content ); |
|
|
|
} |
|
|
|
} |
|
|
|
delete ele[ '#text' ]; |
|
|
|
if ( ele.attributes.type === 'Int64' ) { |
|
|
|
if ( ele.attributes.format === 'binary' ) { |
|
|
|
txt = txt.filter( function ( el, idx ) { |
|
|
|
if ( idx % 2 !== 1 ) return true; |
|
|
|
} ); |
|
|
|
} |
|
|
|
} |
|
|
|
} else { |
|
|
|
if ( ele.attributes.format === 'binary' && ! compressed ) { |
|
|
|
var content = Base64toByteArray( ele[ '#text' ] ); // VTP data for the uncompressed case has the following structure: |
|
// [#bytes][DATA] |
|
// where "[#bytes]" is an integer value specifying the number of bytes in the block of data following it. |
|
|
|
content = content.slice( numBytes ).buffer; |
|
|
|
} else { |
|
|
|
if ( ele[ '#text' ] ) { |
|
|
|
var content = ele[ '#text' ].split( /\s+/ ).filter( function ( el ) { |
|
|
|
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 ); |
|
|
|
} else if ( ele.attributes.type === 'Int32' ) { |
|
|
|
var txt = new Int32Array( content ); |
|
|
|
} else if ( ele.attributes.type === 'Int64' ) { |
|
|
|
var txt = new Int32Array( content ); |
|
|
|
if ( ele.attributes.format === 'binary' ) { |
|
|
|
txt = txt.filter( function ( el, idx ) { |
|
|
|
if ( idx % 2 !== 1 ) return true; |
|
|
|
} ); |
|
|
|
} |
|
|
|
} |
|
|
|
} // endif ( ele.attributes.format === 'binary' && compressed ) |
|
|
|
|
|
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' ); // eslint-disable-line no-undef |
|
|
|
dom.async = false; |
|
|
|
if ( ! dom.loadXML() ) { |
|
|
|
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 && 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 |
|
if ( '#text' in arr[ dataArrayIndex ] && arr[ dataArrayIndex ][ '#text' ].length > 0 ) { |
|
|
|
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 ); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
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 ); |
|
|
|
} |
|
|
|
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 ]; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
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 ]; |
|
|
|
} |
|
|
|
} |
|
|
|
break; |
|
|
|
default: |
|
break; |
|
|
|
} |
|
|
|
} |
|
|
|
sectionIndex ++; |
|
|
|
} |
|
|
|
var geometry = new THREE.BufferGeometry(); |
|
geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) ); |
|
geometry.setAttribute( 'position', new THREE.BufferAttribute( points, 3 ) ); |
|
|
|
if ( normals.length === points.length ) { |
|
|
|
geometry.setAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) ); |
|
|
|
} |
|
|
|
return geometry; |
|
|
|
} else { |
|
|
|
throw new Error( 'Unsupported DATASET type' ); |
|
|
|
} |
|
|
|
} // get the 5 first lines of the files to check if there is the key word binary |
|
|
|
|
|
var meta = THREE.LoaderUtils.decodeText( new Uint8Array( data, 0, 250 ) ).split( '\n' ); |
|
|
|
if ( meta[ 0 ].indexOf( 'xml' ) !== - 1 ) { |
|
|
|
return parseXML( THREE.LoaderUtils.decodeText( data ) ); |
|
|
|
} else if ( meta[ 2 ].includes( 'ASCII' ) ) { |
|
|
|
return parseASCII( THREE.LoaderUtils.decodeText( data ) ); |
|
|
|
} else { |
|
|
|
return parseBinary( data ); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
THREE.VTKLoader = VTKLoader; |
|
|
|
} )();
|
|
|