@kitware/vtk.js 32.3.2 → 32.5.0

package/Common/Core/Math/index.js

@@ -53,6 +53,15 @@ function createArray() {
   return res;
 }
 const Pi = () => Math.PI;
+function ldexp(x, exponent) {
+  if (exponent > 1023) {
+    return x * 2 ** 1023 * 2 ** (exponent - 1023);
+  }
+  if (exponent < -1074) {
+    return x * 2 ** -1074 * 2 ** (exponent + 1074);
+  }
+  return x * 2 ** exponent;
+}
 function radiansFromDegrees(deg) {
   return deg / 180 * Math.PI;
 }
@@ -2012,6 +2021,7 @@ function float2CssRGBA(rgbArray) {
 
 var vtkMath = {
   Pi,
+  ldexp,
   radiansFromDegrees,
   degreesFromRadians,
   round,
@@ -2128,6 +2138,7 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
   createArray: createArray,
   Pi: Pi,
+  ldexp: ldexp,
   radiansFromDegrees: radiansFromDegrees,
   degreesFromRadians: degreesFromRadians,
   round: round,
@@ -2245,4 +2256,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { arrayMin as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, identity as G, multiplyMatrix as H, floor as I, isInf as J, rgb2hsv as K, rgb2lab as L, lab2rgb as M, round as N, normalize2D as O, nearestPowerOfTwo as P, multiply3x3_vect3 as Q, getSparseOrthogonalMatrix as R, areBoundsInitialized as S, isPowerOfTwo as T, angleBetweenVectors as U, signedAngleBetweenVectors as V, createArray as W, Pi as X, ceil as Y, min as Z, max as _, areMatricesEqual as a, float2CssRGBA as a$, arrayMax as a0, ceilLog2 as a1, factorial as a2, binomial as a3, beginCombination as a4, nextCombination as a5, randomSeed as a6, getSeed as a7, gaussian as a8, multiplyScalar2D as a9, diagonalize3x3 as aA, singularValueDecomposition3x3 as aB, luFactorLinearSystem as aC, luSolveLinearSystem as aD, invertMatrix as aE, estimateMatrixCondition as aF, solveHomogeneousLeastSquares as aG, solveLeastSquares as aH, hex2float as aI, lab2xyz as aJ, xyz2lab as aK, xyz2rgb as aL, rgb2xyz as aM, computeBoundsFromPoints as aN, clampAndNormalizeValue as aO, getScalarTypeFittingRange as aP, getAdjustedScalarRange as aQ, extentIsWithinOtherExtent as aR, boundsIsWithinOtherBounds as aS, pointIsWithinBounds as aT, solve3PointCircle as aU, inf as aV, negInf as aW, isFinite as aX, isNaN as aY, floatToHex2 as aZ, floatRGB2HexCode as a_, multiplyAccumulate2D as aa, outer as ab, projectVector as ac, dot2D as ad, projectVector2D as ae, gaussianAmplitude as af, gaussianWeight as ag, outer2D as ah, norm2D as ai, rowsToMat4 as aj, columnsToMat4 as ak, columnsToMat3 as al, LUFactor3x3 as am, LUSolve3x3 as an, linearSolve3x3 as ao, multiply3x3_mat3 as ap, transpose3x3 as aq, invert3x3 as ar, identity3x3 as as, isIdentity as at, isIdentity3x3 as au, quaternionToMatrix3x3 as av, roundNumber as aw, matrix3x3ToQuaternion as ax, multiplyQuaternion as ay, orthogonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { min as $, ldexp as A, xyz2rgb as B, degreesFromRadians as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, isPowerOfTwo as V, angleBetweenVectors as W, signedAngleBetweenVectors as X, createArray as Y, Pi as Z, ceil as _, areMatricesEqual as a, floatRGB2HexCode as a$, max as a0, arrayMin as a1, arrayMax as a2, ceilLog2 as a3, factorial as a4, binomial as a5, beginCombination as a6, nextCombination as a7, randomSeed as a8, getSeed as a9, multiplyQuaternion as aA, orthogonalize3x3 as aB, diagonalize3x3 as aC, singularValueDecomposition3x3 as aD, luFactorLinearSystem as aE, luSolveLinearSystem as aF, invertMatrix as aG, estimateMatrixCondition as aH, solveHomogeneousLeastSquares as aI, solveLeastSquares as aJ, hex2float as aK, lab2xyz as aL, xyz2lab as aM, rgb2xyz as aN, computeBoundsFromPoints as aO, clampAndNormalizeValue as aP, getScalarTypeFittingRange as aQ, getAdjustedScalarRange as aR, extentIsWithinOtherExtent as aS, boundsIsWithinOtherBounds as aT, pointIsWithinBounds as aU, solve3PointCircle as aV, inf as aW, negInf as aX, isFinite as aY, isNaN as aZ, floatToHex2 as a_, gaussian as aa, multiplyScalar2D as ab, multiplyAccumulate2D as ac, outer as ad, projectVector as ae, dot2D as af, projectVector2D as ag, gaussianAmplitude as ah, gaussianWeight as ai, outer2D as aj, norm2D as ak, rowsToMat4 as al, columnsToMat4 as am, columnsToMat3 as an, LUFactor3x3 as ao, LUSolve3x3 as ap, linearSolve3x3 as aq, multiply3x3_mat3 as ar, transpose3x3 as as, invert3x3 as at, identity3x3 as au, isIdentity as av, isIdentity3x3 as aw, quaternionToMatrix3x3 as ax, roundNumber as ay, matrix3x3ToQuaternion as az, roundVector as b, float2CssRGBA as b0, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.d.ts

@@ -51,6 +51,11 @@ export function swapColumnsMatrix_nxn(
  */
 export function Pi(): number;
 
+/**
+ * Calculates x times (2 to the power of exponent).
+ */
+export function ldexp(x: number, exponent: number): number;
+
 /**
  * Convert degrees to radians.
  * @param {Number} deg The value in degrees.

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { am as LUFactor3x3, an as LUSolve3x3, X as Pi, k as add, U as angleBetweenVectors, S as areBoundsInitialized, B as areEquals, a as areMatricesEqual, a0 as arrayMax, $ as arrayMin, D as arrayRange, a4 as beginCombination, a3 as binomial, aS as boundsIsWithinOtherBounds, Y as ceil, a1 as ceilLog2, aO as clampAndNormalizeValue, C as clampValue, c as clampVector, al as columnsToMat3, ak as columnsToMat4, aN as computeBoundsFromPoints, W as createArray, F as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aA as diagonalize3x3, e as distance2BetweenPoints, d as dot, ad as dot2D, aF as estimateMatrixCondition, aR as extentIsWithinOtherExtent, a2 as factorial, a$ as float2CssRGBA, a_ as floatRGB2HexCode, aZ as floatToHex2, I as floor, a8 as gaussian, af as gaussianAmplitude, ag as gaussianWeight, aQ as getAdjustedScalarRange, E as getMajorAxisIndex, aP as getScalarTypeFittingRange, a7 as getSeed, R as getSparseOrthogonalMatrix, aI as hex2float, h as hsv2rgb, G as identity, as as identity3x3, aV as inf, ar as invert3x3, aE as invertMatrix, aX as isFinite, at as isIdentity, au as isIdentity3x3, J as isInf, aY as isNaN, i as isNan, T as isPowerOfTwo, t as jacobi, p as jacobiN, M as lab2rgb, aJ as lab2xyz, ao as linearSolve3x3, aC as luFactorLinearSystem, aD as luSolveLinearSystem, ax as matrix3x3ToQuaternion, _ as max, Z as min, ap as multiply3x3_mat3, Q as multiply3x3_vect3, m as multiplyAccumulate, aa as multiplyAccumulate2D, H as multiplyMatrix, ay as multiplyQuaternion, w as multiplyScalar, a9 as multiplyScalar2D, P as nearestPowerOfTwo, aW as negInf, a5 as nextCombination, n as norm, ai as norm2D, l as normalize, O as normalize2D, az as orthogonalize3x3, ab as outer, ah as outer2D, q as perpendiculars, aT as pointIsWithinBounds, ac as projectVector, ae as projectVector2D, av as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a6 as randomSeed, K as rgb2hsv, L as rgb2lab, aM as rgb2xyz, N as round, aw as roundNumber, b as roundVector, z as rowsToMat3, aj as rowsToMat4, V as signedAngleBetweenVectors, aB as singularValueDecomposition3x3, aU as solve3PointCircle, aG as solveHomogeneousLeastSquares, aH as solveLeastSquares, g as solveLinearSystem, s as subtract, aq as transpose3x3, u as uninitializeBounds, aK as xyz2lab, aL as xyz2rgb } from './Math/index.js';
+export { ao as LUFactor3x3, ap as LUSolve3x3, Z as Pi, k as add, W as angleBetweenVectors, U as areBoundsInitialized, D as areEquals, a as areMatricesEqual, a2 as arrayMax, a1 as arrayMin, F as arrayRange, a6 as beginCombination, a5 as binomial, aT as boundsIsWithinOtherBounds, _ as ceil, a3 as ceilLog2, aP as clampAndNormalizeValue, E as clampValue, c as clampVector, an as columnsToMat3, am as columnsToMat4, aO as computeBoundsFromPoints, Y as createArray, H as createUninitializedBounds, j as cross, f as default, C as degreesFromRadians, o as determinant2x2, y as determinant3x3, aC as diagonalize3x3, e as distance2BetweenPoints, d as dot, af as dot2D, aH as estimateMatrixCondition, aS as extentIsWithinOtherExtent, a4 as factorial, b0 as float2CssRGBA, a$ as floatRGB2HexCode, a_ as floatToHex2, K as floor, aa as gaussian, ah as gaussianAmplitude, ai as gaussianWeight, aR as getAdjustedScalarRange, G as getMajorAxisIndex, aQ as getScalarTypeFittingRange, a9 as getSeed, T as getSparseOrthogonalMatrix, aK as hex2float, h as hsv2rgb, I as identity, au as identity3x3, aW as inf, at as invert3x3, aG as invertMatrix, aY as isFinite, av as isIdentity, aw as isIdentity3x3, L as isInf, aZ as isNaN, i as isNan, V as isPowerOfTwo, t as jacobi, p as jacobiN, O as lab2rgb, aL as lab2xyz, A as ldexp, aq as linearSolve3x3, aE as luFactorLinearSystem, aF as luSolveLinearSystem, az as matrix3x3ToQuaternion, a0 as max, $ as min, ar as multiply3x3_mat3, S as multiply3x3_vect3, m as multiplyAccumulate, ac as multiplyAccumulate2D, J as multiplyMatrix, aA as multiplyQuaternion, w as multiplyScalar, ab as multiplyScalar2D, R as nearestPowerOfTwo, aX as negInf, a7 as nextCombination, n as norm, ak as norm2D, l as normalize, Q as normalize2D, aB as orthogonalize3x3, ad as outer, aj as outer2D, q as perpendiculars, aU as pointIsWithinBounds, ae as projectVector, ag as projectVector2D, ax as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a8 as randomSeed, M as rgb2hsv, N as rgb2lab, aN as rgb2xyz, P as round, ay as roundNumber, b as roundVector, z as rowsToMat3, al as rowsToMat4, X as signedAngleBetweenVectors, aD as singularValueDecomposition3x3, aV as solve3PointCircle, aI as solveHomogeneousLeastSquares, aJ as solveLeastSquares, g as solveLinearSystem, s as subtract, as as transpose3x3, u as uninitializeBounds, aM as xyz2lab, B as xyz2rgb } from './Math/index.js';

package/IO/Image/HDRReader/Utils.js

@@ -0,0 +1,44 @@
+import { A as ldexp } from '../../../Common/Core/Math/index.js';
+
+/**
+ * Read a line from a Uint8Array
+ * @param {Uint8Array} uint8array
+ * @param {number} startIndex
+ * @returns string
+ */
+function readLine(uint8array, startIndex) {
+  let line = '';
+  let character = '';
+  for (let i = startIndex; i < uint8array.length - startIndex; i++) {
+    character = String.fromCharCode(uint8array[i]);
+    if (character === '\n') {
+      break;
+    }
+    line += character;
+  }
+  return line;
+}
+
+/**
+ * Convert rgbe to float
+ * @param {Array} rgbe The rgbe array
+ * @param {Array} floats The output array
+ * @param {number} exposure The exposure value
+ */
+function rgbe2float(rgbe, exposure) {
+  let floats = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  if (rgbe[3] > 0) {
+    /* nonzero pixel */
+    const f = ldexp(1.0, rgbe[3] - (128 + 8)) / exposure;
+    floats[0] = rgbe[0] * f;
+    floats[1] = rgbe[1] * f;
+    floats[2] = rgbe[2] * f;
+  } else {
+    floats[0] = 0;
+    floats[1] = 0;
+    floats[2] = 0;
+  }
+  return floats;
+}
+
+export { readLine, rgbe2float };

package/IO/Image/HDRReader.d.ts

@@ -0,0 +1,121 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import HtmlDataAccessHelper from './../Core/DataAccessHelper/HtmlDataAccessHelper';
+import HttpDataAccessHelper from './../Core/DataAccessHelper/HttpDataAccessHelper';
+import JSZipDataAccessHelper from './../Core/DataAccessHelper/JSZipDataAccessHelper';
+import LiteHttpDataAccessHelper from './../Core/DataAccessHelper/LiteHttpDataAccessHelper';
+
+interface IHDRReaderOptions {
+  compression?: string;
+  progressCallback?: any;
+}
+
+/**
+ *
+ */
+export interface IHDRReaderInitialValues {}
+
+type vtkHDRReaderBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkHDRReader extends vtkHDRReaderBase {
+  /**
+   * Get the base url.
+   */
+  getBaseURL(): string;
+
+  /**
+   * Get the dataAccess helper.
+   */
+  getDataAccessHelper():
+    | HtmlDataAccessHelper
+    | HttpDataAccessHelper
+    | JSZipDataAccessHelper
+    | LiteHttpDataAccessHelper;
+
+  /**
+   * Get the url of the object to load.
+   */
+  getUrl(): string;
+
+  /**
+   * Load the object data.
+   * @param {IHDRReaderOptions} [options]
+   */
+  loadData(options?: IHDRReaderOptions): Promise<any>;
+
+  /**
+   * Parse data.
+   * @param {ArrayBuffer} content The content to parse.
+   */
+  parse(content: ArrayBuffer): void;
+
+  /**
+   * Parse data as ArrayBuffer.
+   * @param {ArrayBuffer} content The content to parse.
+   */
+  parseAsArrayBuffer(content: ArrayBuffer): void;
+
+  /**
+   *
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   *
+   * @param dataAccessHelper
+   */
+  setDataAccessHelper(
+    dataAccessHelper:
+      | HtmlDataAccessHelper
+      | HttpDataAccessHelper
+      | JSZipDataAccessHelper
+      | LiteHttpDataAccessHelper
+  ): boolean;
+
+  /**
+   * Set the url of the object to load.
+   * @param {String} url the url of the object to load.
+   * @param {IHDRReaderOptions} [option] The PLY reader options.
+   */
+  setUrl(url: string, option?: IHDRReaderOptions): Promise<string | any>;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkHDRReader characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IHDRReaderInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IHDRReaderInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkHDRReader
+ * @param {IHDRReaderInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IHDRReaderInitialValues
+): vtkHDRReader;
+
+/**
+ * vtkHDRReader is a source object that reads Radiance HDR files.
+ */
+export declare const vtkHDRReader: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkHDRReader;

package/IO/Image/HDRReader.js

@@ -0,0 +1,373 @@
+import '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';
+import { m as macro } from '../../macros2.js';
+import DataAccessHelper from '../Core/DataAccessHelper.js';
+import { B as xyz2rgb } from '../../Common/Core/Math/index.js';
+import vtkImageData from '../../Common/DataModel/ImageData.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import { readLine, rgbe2float } from './HDRReader/Utils.js';
+
+/* eslint-disable no-bitwise */
+const {
+  vtkErrorMacro
+} = macro;
+const FormatType = {
+  FORMAT_32BIT_RLE_RGBE: 0,
+  FORMAT_32BIT_RLE_XYZE: 1
+};
+const Patterns = {
+  magicToken: /^#\?(\S+)/,
+  gamma: /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/,
+  exposure: /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/,
+  format: /^\s*FORMAT=(\S+)\s*$/,
+  dimensions: /^\s*-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/
+};
+
+// ----------------------------------------------------------------------------
+// vtkHDRReader methods
+// ----------------------------------------------------------------------------
+
+function vtkHDRReader(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkHDRReader');
+
+  /**
+   * Reads header information from an RGBE texture stored in a native array.
+   * More information on this format are available here:
+   * https://en.wikipedia.org/wiki/RGBE_image_format
+   *
+   * @param {Uint8Array} uint8array The binary file stored in  native array.
+   * @returns The header information.
+   */
+  function readHeader(uint8array) {
+    // RGBE format header
+    const header = {
+      valid: 0,
+      string: '',
+      comments: '',
+      programtype: 'RGBE',
+      format: '',
+      gamma: 1.0,
+      exposure: 1.0,
+      pixelAspect: 1.0,
+      width: 0,
+      height: 0,
+      dataIndex: 0
+    };
+    let match;
+    let line = readLine(uint8array, 0);
+    match = line.match(Patterns.magicToken);
+    if (!match) {
+      throw new Error('Bad HDR Format.');
+    }
+    header.programtype = match[1];
+    header.string += `${line}\n`;
+    let lineIndex = 0;
+    do {
+      lineIndex += line.length + 1;
+      line = readLine(uint8array, lineIndex);
+      header.string += `${line}\n`;
+      if (line.charAt(0) === '#') {
+        header.comments += `${line}\n`;
+        // eslint-disable-next-line no-continue
+        continue; // comment line
+      }
+
+      match = line.match(Patterns.gamma);
+      if (match) {
+        header.gamma = parseFloat(match[1]);
+      }
+      match = line.match(Patterns.exposure);
+      if (match) {
+        header.exposure = parseFloat(match[1]);
+      }
+      match = line.match(Patterns.format);
+      if (match) {
+        header.format = match[1];
+      }
+    } while (line.length !== 0);
+    lineIndex += line.length + 1;
+    line = readLine(uint8array, lineIndex);
+    match = line.match(Patterns.dimensions);
+    if (match) {
+      header.height = parseInt(match[1], 10);
+      header.width = parseInt(match[2], 10);
+    }
+    if (header.width < 8 || header.width > 0x7fff) {
+      vtkErrorMacro('HDR Bad header format, unsupported size');
+    }
+    lineIndex += line.length + 1;
+    header.dataIndex = lineIndex;
+    return header;
+  }
+
+  /**
+   *
+   * @param {Uint8Array} uint8array
+   * @param {*} header
+   * @returns Float32Array
+   */
+  function readRGBEPixelsNotRLE(uint8array, header) {
+    // this file is not run length encoded
+    // read values sequentially
+
+    let numScanlines = header.height;
+    const scanlineWidth = header.width;
+    let a;
+    let b;
+    let c;
+    let d;
+    let i;
+    let dataIndex = header.dataIndex;
+
+    // 3 channels of 4 bytes per pixel in float.
+    const resultBuffer = new ArrayBuffer(header.width * header.height * 4 * 3);
+    const resultArray = new Float32Array(resultBuffer);
+
+    // read in each successive scanline
+    while (numScanlines > 0) {
+      for (i = 0; i < header.width; i++) {
+        a = uint8array[dataIndex++];
+        b = uint8array[dataIndex++];
+        c = uint8array[dataIndex++];
+        d = uint8array[dataIndex++];
+        const offset = (numScanlines - 1) * scanlineWidth * 3 + i * 3;
+        let output = [];
+        const input = [a, b, c, d];
+        if (model.format === FormatType.FORMAT_32BIT_RLE_XYZE) {
+          // convert from XYZE to RGBE
+          xyz2rgb(input, output);
+        } else {
+          output = rgbe2float(input, model.exposure);
+        }
+        resultArray[offset] = output[0];
+        resultArray[offset + 1] = output[1];
+        resultArray[offset + 2] = output[2];
+      }
+      numScanlines--;
+    }
+    return resultArray;
+  }
+
+  /**
+   *
+   * @param {Uint8Array} uint8array
+   * @param {*} header
+   * @returns Float32Array
+   */
+  function readRGBEPixelsRLE(uint8array, header) {
+    let numScanlines = header.height;
+    const scanlineWidth = header.width;
+    let a;
+    let b;
+    let c;
+    let d;
+    let count;
+    let dataIndex = header.dataIndex;
+    let index = 0;
+    let endIndex = 0;
+    let i = 0;
+    const scanLineArrayBuffer = new ArrayBuffer(scanlineWidth * 4); // four channel R G B E
+    const scanLineArray = new Uint8Array(scanLineArrayBuffer);
+
+    // 3 channels of 4 bytes per pixel in float.
+    const resultBuffer = new ArrayBuffer(header.width * header.height * 4 * 3);
+    const resultArray = new Float32Array(resultBuffer);
+
+    // read in each successive scanline
+    while (numScanlines > 0) {
+      a = uint8array[dataIndex++];
+      b = uint8array[dataIndex++];
+      c = uint8array[dataIndex++];
+      d = uint8array[dataIndex++];
+      if (a !== 2 || b !== 2 || c & 0x80 || header.width < 8 || header.width > 32767) {
+        return readRGBEPixelsNotRLE(uint8array, header);
+      }
+      if ((c << 8 | d) !== scanlineWidth) {
+        vtkErrorMacro('HDR Bad header format, wrong scan line width');
+      }
+      index = 0;
+
+      // read each of the four channels for the scanline into the buffer
+      for (i = 0; i < 4; i++) {
+        endIndex = (i + 1) * scanlineWidth;
+        while (index < endIndex) {
+          a = uint8array[dataIndex++];
+          b = uint8array[dataIndex++];
+          if (a > 128) {
+            // A run of the same value
+            count = a - 128;
+            if (count === 0 || count > endIndex - index) {
+              vtkErrorMacro('HDR Bad Format, bad scanline data (run)');
+            }
+            while (count-- > 0) {
+              scanLineArray[index++] = b;
+            }
+          } else {
+            // A non run
+            count = a;
+            if (count === 0 || count > endIndex - index) {
+              vtkErrorMacro('HDR Bad Format, bad scanline data (non-run)');
+            }
+            scanLineArray[index++] = b;
+            if (--count > 0) {
+              for (let j = 0; j < count; j++) {
+                scanLineArray[index++] = uint8array[dataIndex++];
+              }
+            }
+          }
+        }
+      }
+
+      // now convert data from buffer into floats
+      for (i = 0; i < scanlineWidth; i++) {
+        a = scanLineArray[i];
+        b = scanLineArray[i + scanlineWidth];
+        c = scanLineArray[i + 2 * scanlineWidth];
+        d = scanLineArray[i + 3 * scanlineWidth];
+        const offset = (numScanlines - 1) * scanlineWidth * 3 + i * 3;
+        let output = [];
+        const input = [a, b, c, d];
+        if (model.format === FormatType.FORMAT_32BIT_RLE_XYZE) {
+          // convert from XYZE to RGBE
+          xyz2rgb(input, output);
+        } else {
+          output = rgbe2float(input, model.exposure);
+        }
+        resultArray[offset] = output[0];
+        resultArray[offset + 1] = output[1];
+        resultArray[offset + 2] = output[2];
+      }
+      numScanlines--;
+    }
+    return resultArray;
+  }
+
+  // Create default dataAccessHelper if not available
+  if (!model.dataAccessHelper) {
+    model.dataAccessHelper = DataAccessHelper.get('http');
+  }
+
+  // Internal method to fetch Array
+  function fetchData(url) {
+    const {
+      compression,
+      progressCallback
+    } = model;
+    return model.dataAccessHelper.fetchBinary(url, {
+      compression,
+      progressCallback
+    });
+  }
+
+  // Set DataSet url
+  publicAPI.setUrl = function (url) {
+    let option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      binary: true
+    };
+    model.url = url;
+
+    // Remove the file in the URL
+    const path = url.split('/');
+    path.pop();
+    model.baseURL = path.join('/');
+    model.compression = option.compression;
+
+    // Fetch metadata
+    return publicAPI.loadData({
+      progressCallback: option.progressCallback
+    });
+  };
+
+  // Fetch the actual data arrays
+  publicAPI.loadData = function () {
+    const promise = fetchData(model.url);
+    promise.then(publicAPI.parse);
+    return promise;
+  };
+  publicAPI.parse = content => {
+    publicAPI.parseAsArrayBuffer(content);
+  };
+  publicAPI.parseAsArrayBuffer = content => {
+    if (!content) {
+      return;
+    }
+    model.parseData = content;
+    const data = new Uint8Array(model.parseData);
+    const header = readHeader(data);
+    if (header.format === '32-bit_rle_rgbe') {
+      model.format = FormatType.FORMAT_32BIT_RLE_RGBE;
+    } else if (header.format === '32-bit_rle_xyze') {
+      model.format = FormatType.FORMAT_32BIT_RLE_XYZE;
+    }
+    model.gamma = header.gamma;
+    model.exposure = header.exposure;
+    model.pixelAspect = header.pixelAspect;
+    const output = readRGBEPixelsRLE(data, header);
+    const dataExtent = [0, header.width - 1, 0, header.height - 1];
+    const dataSpacing = [1, header.pixelAspect, 1];
+    const imageData = vtkImageData.newInstance();
+    imageData.setDimensions(header.width, header.height, 1);
+    imageData.setExtent(dataExtent);
+    imageData.setSpacing(dataSpacing);
+    const dataArray = vtkDataArray.newInstance({
+      name: 'HDRImage',
+      numberOfComponents: 3,
+      values: output
+    });
+    imageData.getPointData().setScalars(dataArray);
+    model.output[0] = imageData;
+  };
+  publicAPI.requestData = (inData, outData) => {
+    publicAPI.parse(model.parseData);
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  gamma: 1.0,
+  exposure: 1.0,
+  pixelAspect: 1.0,
+  format: FormatType.FORMAT_32BIT_RLE_RGBE
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
+
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 0, 1);
+  macro.get(publicAPI, model, ['gamma', 'exposure', 'pixelAspect', 'url', 'baseURL']);
+  macro.setGet(publicAPI, model, ['dataAccessHelper']);
+
+  // Object specific methods
+  vtkHDRReader(publicAPI, model);
+
+  // To support destructuring
+  if (!model.compression) {
+    model.compression = null;
+  }
+  if (!model.progressCallback) {
+    model.progressCallback = null;
+  }
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkHDRReader');
+
+// ----------------------------------------------------------------------------
+
+var vtkHDRReader$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkHDRReader$1 as default, extend, newInstance };

package/IO/Image.js

@@ -0,0 +1,7 @@
+import vtkHDRReader from './Image/HDRReader.js';
+
+var index = {
+  vtkHDRReader
+};
+
+export { index as default };