opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/VTKLoader.js

@@ -0,0 +1,894 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "../libs/fflate.module.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("../libs/fflate.module.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.fflateModule);
+    global.VTKLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, fflate) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.VTKLoader = void 0;
+  fflate = _interopRequireWildcard(fflate);
+
+  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var VTKLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(VTKLoader, _Loader);
+
+    var _super = _createSuper(VTKLoader);
+
+    function VTKLoader(manager) {
+      _classCallCheck(this, VTKLoader);
+
+      return _super.call(this, manager);
+    }
+
+    _createClass(VTKLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var 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);
+      }
+    }, {
+      key: "parse",
+      value: function 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) {
+          var 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);
+        }
+      }
+    }]);
+
+    return VTKLoader;
+  }(_three.Loader);
+
+  _exports.VTKLoader = VTKLoader;
+});