zincjs 3.0.0 → 3.0.1

package/src/loaders/niftiReader.js

@@ -4,36 +4,36 @@ import { TextureArray } from '../texture/textureArray';
 import { TextureSlides } from '../primitives/textureSlides';
 
 const defaultTextureSettings = {
-  "id": "mesh-location-orientation",
-  "locations": [
+  id: 'mesh-location-orientation',
+  locations: [
     {
-      "identifier": 1,
-      "label": "original",
-      "orientation": [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0],
-      "position": [0, 0, 0],
-      "scale": [1, 1, 1],
-      "flipY": false,
-      "flipZ": false,
-      "reference_point": "corner"
-    }
+      identifier: 1,
+      label: 'original',
+      orientation: [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0],
+      position: [0, 0, 0],
+      scale: [1, 1, 1],
+      flipY: false,
+      flipZ: false,
+      reference_point: 'corner',
+    },
   ],
-  "settings": {
-    "slides": [
+  settings: {
+    slides: [
       {
-        "direction": "x",
-        "value": 0.5
+        direction: 'x',
+        value: 0.5,
       },
       {
-        "direction": "y",
-        "value": 0.5
+        direction: 'y',
+        value: 0.5,
       },
       {
-        "direction": "z",
-        "value": 0.5
-      }
-    ]
+        direction: 'z',
+        value: 0.5,
+      },
+    ],
   },
-  "type": "slides"
+  type: 'slides',
 };
 
 const defaultOptions = {
@@ -43,7 +43,6 @@ const defaultOptions = {
   timeEnabled: false,
 };
 
-
 /*
 const exampleSettings = {
   v1: {
@@ -117,26 +116,42 @@ function readNIFTI(data) {
   if (nifti.isNIFTI(fullData)) {
     let niftiHeader = nifti.readHeader(fullData);
     let niftiImage = nifti.readImage(niftiHeader, fullData);
-    return {niftiHeader, niftiImage};
+    return { niftiHeader, niftiImage };
   }
   fullData = undefined;
-  return {niftiHeader: undefined, niftiImage: undefined};
+  return { niftiHeader: undefined, niftiImage: undefined };
 }
 
-
 function convertNiftiToUint8Array(niftiHeader, niftiImage) {
   // 1. Parse the raw array using the correct native typed array view
   let rawData;
   switch (niftiHeader.datatypeCode) {
-    case nifti.NIFTI1.TYPE_UINT8:   rawData = new Uint8Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_INT8:    rawData = new Int8Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_UINT16:  rawData = new Uint16Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_INT16:   rawData = new Int16Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_UINT32:  rawData = new Uint32Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_INT32:   rawData = new Int32Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_FLOAT32: rawData = new Float32Array(niftiImage); break;
-    case nifti.NIFTI1.TYPE_FLOAT64: rawData = new Float64Array(niftiImage); break;
-    default: throw new Error("Unsupported NIfTI data type");
+    case nifti.NIFTI1.TYPE_UINT8:
+      rawData = new Uint8Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_INT8:
+      rawData = new Int8Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_UINT16:
+      rawData = new Uint16Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_INT16:
+      rawData = new Int16Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_UINT32:
+      rawData = new Uint32Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_INT32:
+      rawData = new Int32Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_FLOAT32:
+      rawData = new Float32Array(niftiImage);
+      break;
+    case nifti.NIFTI1.TYPE_FLOAT64:
+      rawData = new Float64Array(niftiImage);
+      break;
+    default:
+      throw new Error('Unsupported NIfTI data type');
   }
 
   let min = Infinity;
@@ -168,8 +183,12 @@ function createSources(niftiHeader, niftiImage, maskHeader, maskImage) {
     const height = niftiHeader.dims[2];
     const depth = niftiHeader.dims[3];
     let isRGB = false;
-    if (niftiHeader.intent_code === 1007 || niftiHeader.intent_code === 1008 ||
-      niftiHeader.datatypeCode === 128 || niftiHeader.datatypeCode === 2304) {
+    if (
+      niftiHeader.intent_code === 1007 ||
+      niftiHeader.intent_code === 1008 ||
+      niftiHeader.datatypeCode === 128 ||
+      niftiHeader.datatypeCode === 2304
+    ) {
       isRGB = true;
     }
     const typedData = convertNiftiToUint8Array(niftiHeader, niftiImage);
@@ -212,24 +231,23 @@ function getSFormTransformation(header, options) {
       scale[1] = Math.abs(scale[1]);
       scale[2] = Math.abs(scale[2]);
     }
-    return {position, scale}
+    return { position, scale };
   }
-  return {position: undefined, scale: undefined}
+  return { position: undefined, scale: undefined };
 }
 
 function getTransformationFromHeader(header, options) {
   if (header) {
     if (header.sform_code) {
-      return getSFormTransformation(header, options)
+      return getSFormTransformation(header, options);
     }
   }
 
-  return {position: undefined, scale: undefined}
+  return { position: undefined, scale: undefined };
 }
 
 function createDataTexture(data, width, height, depth, isRGB) {
-  const dataTexture = new THREE.Data3DTexture(
-    data, width, height, depth);
+  const dataTexture = new THREE.Data3DTexture(data, width, height, depth);
   dataTexture.anisotropy = 4;
   if (!isRGB) {
     dataTexture.format = THREE.RedFormat;
@@ -245,7 +263,11 @@ function createTextureArray(sources) {
   if (sources?.data) {
     const tArray = new TextureArray();
     const dataTexutre = createDataTexture(
-        sources.data, sources.width, sources.height, sources.depth);
+      sources.data,
+      sources.width,
+      sources.height,
+      sources.depth,
+    );
     tArray.setDataTexture(dataTexutre);
     tArray.size = {
       width: sources.width,
@@ -260,14 +282,14 @@ function createTextureArray(sources) {
 
 function createTexturePrimitives(niftiHeader, sources, useHeaderInfo, textureSettings, optionsIn) {
   if (sources?.data) {
-    const options = {...defaultOptions};
+    const options = { ...defaultOptions };
     if (optionsIn) {
       Object.assign(options, optionsIn);
     }
     const newTexture = new TextureSlides();
     const tArray = createTextureArray(sources);
     if (tArray) {
-      newTexture.groupName = "Images";
+      newTexture.groupName = 'Images';
       newTexture.morph.renderOrder = 1;
       newTexture.texture = tArray;
       const settings = structuredClone(defaultTextureSettings);
@@ -275,7 +297,7 @@ function createTexturePrimitives(niftiHeader, sources, useHeaderInfo, textureSet
       //The following will allow the dimension and upset to be
       //set using the information from the header
       if (useHeaderInfo && niftiHeader) {
-        const {position, scale} = getTransformationFromHeader(niftiHeader, options);
+        const { position, scale } = getTransformationFromHeader(niftiHeader, options);
         if (position && scale) {
           settings.locations[0].scale = scale;
           settings.locations[0].position = position;
@@ -284,8 +306,13 @@ function createTexturePrimitives(niftiHeader, sources, useHeaderInfo, textureSet
       newTexture.initialise(settings, undefined);
       newTexture.showEdges(0x999999);
       if (sources.maskData && !options.timeEnabled) {
-        const maskTexture = createDataTexture(sources.maskData,
-          sources.width, sources.height, sources.depth, false);
+        const maskTexture = createDataTexture(
+          sources.maskData,
+          sources.width,
+          sources.height,
+          sources.depth,
+          false,
+        );
         newTexture.setMask(maskTexture);
       }
       newTexture.setNumberOfChannels(sources.isRGB ? 3 : 1);
@@ -297,9 +324,9 @@ function createTexturePrimitives(niftiHeader, sources, useHeaderInfo, textureSet
 }
 
 async function getImagesFromURL(url, maskURL) {
-
   //  try {
-  let maskHeader = undefined, maskImage = undefined;
+  let maskHeader = undefined,
+    maskImage = undefined;
   if (maskURL) {
     const mask = await fetch(maskURL);
     const maskBuffer = await mask.arrayBuffer();
@@ -309,14 +336,12 @@ async function getImagesFromURL(url, maskURL) {
   }
   const response = await fetch(url);
   const buffer = await response.arrayBuffer();
-  const {niftiHeader, niftiImage} = readNIFTI(buffer);
+  const { niftiHeader, niftiImage } = readNIFTI(buffer);
   const sources = createSources(niftiHeader, niftiImage, maskHeader, maskImage);
-  return {sources, niftiHeader};
+  return { sources, niftiHeader };
 }
 
-
-async function createPrimitivesFromNIFTI(
-  url, useHeaderInfo, maskURL, textureSettings, optionsIn) {
+async function createPrimitivesFromNIFTI(url, useHeaderInfo, maskURL, textureSettings, optionsIn) {
   let timeEnabled = false;
   let textureP = undefined;
   let firstURL = url;
@@ -327,8 +352,14 @@ async function createPrimitivesFromNIFTI(
     }
   }
   if (typeof firstURL === 'string') {
-    const {sources, niftiHeader} = await getImagesFromURL(firstURL, maskURL, optionsIn);
-    textureP = createTexturePrimitives(niftiHeader, sources, useHeaderInfo, textureSettings, optionsIn);
+    const { sources, niftiHeader } = await getImagesFromURL(firstURL, maskURL, optionsIn);
+    textureP = createTexturePrimitives(
+      niftiHeader,
+      sources,
+      useHeaderInfo,
+      textureSettings,
+      optionsIn,
+    );
   }
   if (timeEnabled && textureP) {
     for (let i = 1; i < url.length; i++) {
@@ -342,7 +373,7 @@ async function createPrimitivesFromNIFTI(
 }
 
 async function createTextureFromNIFTI(url, maskURL, optionsIn) {
-  const {sources} = await getImagesFromURL(url, maskURL, optionsIn);
+  const { sources } = await getImagesFromURL(url, maskURL, optionsIn);
   return createTextureArray(sources);
 }
 

package/src/loaders/primitivesLoader.js

@@ -13,7 +13,7 @@ const mergeGlyphData = (glyphData) => {
       }
     }
     const fields = ['axis1', 'axis2', 'axis3', 'colors', 'positions', 'scale'];
-    fields.forEach(field => {
+    fields.forEach((field) => {
       if (field in glyphData1) {
         Object.keys(glyphData1[field]).forEach((step) => {
           const len = glyphData2[field][step].length;
@@ -23,15 +23,15 @@ const mergeGlyphData = (glyphData) => {
         });
       }
     });
-  }
+  };
 
   if (glyphData && glyphData.length > 0) {
     while (glyphData.length > 1) {
-      const glyphData2 = glyphData.splice(1,1);
+      const glyphData2 = glyphData.splice(1, 1);
       merge(glyphData[0], glyphData2[0]);
     }
   }
-}
+};
 
 const mergeGeometries = (geometries) => {
   if (geometries && geometries.length > 0) {
@@ -43,9 +43,9 @@ const mergeGeometries = (geometries) => {
     return merged;
   }
   return undefined;
-}
+};
 
-const IndexedSourcesHandler = function(urlIn, crossOrigin, onDownloadedCallback, onErrorCallback) {
+const IndexedSourcesHandler = function (urlIn, crossOrigin, onDownloadedCallback, onErrorCallback) {
   const fileLoader = new FileLoader();
   const jsonLoader = new JSONLoader();
   fileLoader.crossOrigin = crossOrigin;
@@ -61,25 +61,25 @@ const IndexedSourcesHandler = function(urlIn, crossOrigin, onDownloadedCallback,
   const processItemDownloaded = (item) => {
     const modelData = data[item.index];
     if (modelData) {
-      if ("GlyphGeometriesURL" in modelData) {
+      if ('GlyphGeometriesURL' in modelData) {
         item.onLoad(modelData);
       } else {
-        let obj = jsonLoader.parse( modelData );
+        let obj = jsonLoader.parse(modelData);
         item.onLoad(obj.geometry, obj.materials);
       }
     } else {
-      processItemError(item, {responseURL: url});
+      processItemError(item, { responseURL: url });
     }
-  }
+  };
 
   const processItemError = (item) => {
     if (item.onError) {
       if (!error) {
-        error = {responseURL: url};
+        error = { responseURL: url };
       }
       item.onError(error);
     }
-  }
+  };
 
   this.downloadCompleted = (args) => {
     try {
@@ -87,17 +87,17 @@ const IndexedSourcesHandler = function(urlIn, crossOrigin, onDownloadedCallback,
       downloading = false;
       finished = true;
       if (Array.isArray(data)) {
-        items.forEach(item => processItemDownloaded(item));
+        items.forEach((item) => processItemDownloaded(item));
       } else {
-        items.forEach(item => processItemError(item));
+        items.forEach((item) => processItemError(item));
       }
     } catch {
-      items.forEach(item => processItemError(item));
+      items.forEach((item) => processItemError(item));
     }
-  }
+  };
 
   const errorHandling = () => {
-    return xhr => {
+    return (xhr) => {
       error = xhr;
       finished = true;
       downloading = false;
@@ -107,18 +107,18 @@ const IndexedSourcesHandler = function(urlIn, crossOrigin, onDownloadedCallback,
       if (onDownloadError) {
         onDownloadError(xhr);
       }
-    }
-  }
+    };
+  };
 
   const progressHandling = () => {
-    return xhr => {
+    return (xhr) => {
       items.forEach((item) => {
         if (item.onProgress) {
           item.onProgress(xhr);
         }
       });
-    }
-  }
+    };
+  };
 
   this.load = (index, onLoad, onProgress, onError) => {
     const item = {
@@ -141,10 +141,10 @@ const IndexedSourcesHandler = function(urlIn, crossOrigin, onDownloadedCallback,
       downloading = true;
       fileLoader.load(url, onDownloaded, progressHandling(), errorHandling());
     }
-  }
-}
+  };
+};
 
-const MultiSourcesHandler = function(numberIn, onLoadCallback, onErrorCallback, options) {
+const MultiSourcesHandler = function (numberIn, onLoadCallback, onErrorCallback, options) {
   const allData = [];
   const number = numberIn;
   const onLoad = onLoadCallback;
@@ -166,7 +166,7 @@ const MultiSourcesHandler = function(numberIn, onLoadCallback, onErrorCallback,
     if (onError) {
       onError(...failure);
     }
-  }
+  };
 
   this.itemFailed = (order, args) => {
     if (!failure) {
@@ -176,10 +176,10 @@ const MultiSourcesHandler = function(numberIn, onLoadCallback, onErrorCallback,
     if (totalDownloaded == number) {
       reportFailure();
     }
-  }
+  };
 
   this.itemDownloaded = (order, args) => {
-    allData[order]= args;
+    allData[order] = args;
     totalDownloaded++;
     if (totalDownloaded == number) {
       if (failure) {
@@ -199,23 +199,23 @@ const MultiSourcesHandler = function(numberIn, onLoadCallback, onErrorCallback,
           onLoad(geometry, materials);
         } else {
           const glyphData = allData.map((item) => {
-            return JSON.parse(item[0])
+            return JSON.parse(item[0]);
           });
           mergeGlyphData(glyphData);
           onLoad(glyphData[0]);
         }
       }
     }
-  }
-}
+  };
+};
 
 const PrimitivesLoader = function () {
   let concurrentDownloads = 0;
   const MAX_DOWNLOAD = 20;
-  this.crossOrigin = "Anonymous";
+  this.crossOrigin = 'Anonymous';
   const jsonloader = new JSONLoader();
   const fileloader = new FileLoader();
-  fileloader.crossOrigin = "Anonymous";
+  fileloader.crossOrigin = 'Anonymous';
   const waitingList = [];
   //URL to loader pair
   const indexedLoaders = {};
@@ -227,24 +227,28 @@ const PrimitivesLoader = function () {
     //The order here will give us hint on the sequence on merging the primitives
     let order = 0;
     urls.forEach((url) => {
-      const newOptions = options ? {...options} : {};
+      const newOptions = options ? { ...options } : {};
       newOptions.msHandler = msHandler;
       newOptions.order = order;
       order++;
       loadFromSingleSource(url, onLoad, onProgress, onError, newOptions);
     });
-  }
+  };
 
   const handleIndexedSource = (url, onLoad, onProgress, onError, options) => {
-    const newOptions = options ? {...options} : {};
+    const newOptions = options ? { ...options } : {};
     let indexedLoader = indexedLoaders[url];
     if (!indexedLoader) {
       if (MAX_DOWNLOAD > concurrentDownloads) {
         const onLoadCallback = new onFinally(undefined, this, newOptions);
         const onErrorCallback = new onFinally(undefined, this, {});
         ++concurrentDownloads;
-        indexedLoader = new IndexedSourcesHandler(url, this.crossOrigin, onLoadCallback,
-          onErrorCallback);
+        indexedLoader = new IndexedSourcesHandler(
+          url,
+          this.crossOrigin,
+          onLoadCallback,
+          onErrorCallback,
+        );
         indexedLoaders[url] = indexedLoader;
       } else {
         waitingList.push({
@@ -260,10 +264,10 @@ const PrimitivesLoader = function () {
       newOptions.isHandler = indexedLoader;
       indexedLoader.load(options.index, onLoad, onProgress, onError);
     }
-  }
+  };
 
   const loadFromSingleSource = (url, onLoad, onProgress, onError, options) => {
-    if (options && (options.index !== undefined) ) {
+    if (options && options.index !== undefined) {
       handleIndexedSource(url, onLoad, onProgress, onError, options);
     } else {
       //Standard loading
@@ -287,7 +291,7 @@ const PrimitivesLoader = function () {
         });
       }
     }
-  }
+  };
 
   this.load = (url, onLoad, onProgress, onError, options) => {
     if (Array.isArray(url)) {
@@ -295,7 +299,7 @@ const PrimitivesLoader = function () {
     } else {
       loadFromSingleSource(url, onLoad, onProgress, onError, options);
     }
-  }
+  };
 
   this.loadFromWaitingList = () => {
     while (MAX_DOWNLOAD > concurrentDownloads) {
@@ -306,7 +310,7 @@ const PrimitivesLoader = function () {
         return;
       }
     }
-  }
+  };
 
   this.itemRemainingCheck = () => {
     if (waitingList.length === 0 && concurrentDownloads === 0) {
@@ -316,9 +320,9 @@ const PrimitivesLoader = function () {
         }
       }
     }
-  }
+  };
 
-  const onFinally = function(callback, loader, options, isError = false) {
+  const onFinally = function (callback, loader, options, isError = false) {
     return (...args) => {
       --concurrentDownloads;
       if (options?.msHandler) {
@@ -336,13 +340,12 @@ const PrimitivesLoader = function () {
       }
       loader.loadFromWaitingList();
       loader.itemRemainingCheck();
-    }
-  }
+    };
+  };
 
-  this.parse = data => {
+  this.parse = (data) => {
     return jsonloader.parse(data);
-  }
-
-}
+  };
+};
 
-export { PrimitivesLoader };
+export { PrimitivesLoader };