@aics/vole-core 3.12.4

package/es/test/VolumeCache.test.js

@@ -0,0 +1,118 @@
+import { expect } from "chai";
+import VolumeCache from "../VolumeCache";
+describe("VolumeCache", () => {
+  it("creates an empty cache with the specified max size", () => {
+    const cache = new VolumeCache(10);
+    expect(cache.size).to.equal(0);
+    expect(cache.maxSize).to.equal(10);
+  });
+  describe("insert", () => {
+    it("adds a new entry to the cache", () => {
+      const cache = new VolumeCache();
+      expect(cache.get("1")).to.be.undefined;
+      const insertionResult = cache.insert("1", new Uint8Array(4));
+      expect(insertionResult).to.be.true;
+      expect(cache.get("1")).to.deep.equal(new Uint8Array(4));
+    });
+    it("does not insert an entry if it is too big for the cache", () => {
+      const cache = new VolumeCache(6);
+      const insertionResult = cache.insert("1", new Uint8Array(8));
+      expect(insertionResult).to.be.false;
+      expect(cache.get("1")).to.be.undefined;
+    });
+    it("evicts the least recently used entry when above its size limit", () => {
+      const cache = new VolumeCache(12); // max: 12
+
+      cache.insert("0", new Uint8Array(8)); // 8 < 12
+      cache.insert("1", new Uint8Array(2)); // 10 < 12
+      cache.insert("2", new Uint8Array(8)); // 18 > 12! evict 1!
+
+      expect(cache.size).to.equal(10);
+      expect(cache.numberOfEntries).to.equal(2);
+      expect(cache.get("0")).to.be.undefined;
+      expect(cache.get("1")).to.deep.equal(new Uint8Array(2));
+      expect(cache.get("2")).to.deep.equal(new Uint8Array(8));
+    });
+    it("evicts as many entries as it takes to get below max size", () => {
+      const cache = new VolumeCache(12);
+      cache.insert("0", new Uint8Array(6)); // 6
+      cache.insert("1", new Uint8Array(6)); // 12
+      cache.insert("2", new Uint8Array(8)); // 20!
+
+      expect(cache.size).to.equal(8);
+      expect(cache.numberOfEntries).to.equal(1);
+      expect(cache.get("0")).to.be.undefined;
+      expect(cache.get("1")).to.be.undefined;
+      expect(cache.get("2")).to.deep.equal(new Uint8Array(8));
+    });
+    it("reuses any entries that match the provided key", () => {
+      const cache = new VolumeCache(12);
+      cache.insert("0", new Uint8Array([1, 2, 3, 4])); // 4
+      cache.insert("1", new Uint8Array(8)); // 12
+      cache.insert("0", new Uint8Array([5, 6, 7, 8])); // still 12
+
+      expect(cache.size).to.equal(12);
+      expect(cache.numberOfEntries).to.equal(2);
+      expect(cache.get("1")).to.deep.equal(new Uint8Array(8));
+      expect(cache.get("0")).to.deep.equal(new Uint8Array([5, 6, 7, 8]));
+    });
+  });
+  const SLICE_0 = [1, 2, 3, 4];
+  const SLICE_1 = [5, 6, 7, 8];
+  const SLICE_2 = [2, 4, 6, 8];
+  const SLICE_3 = [1, 3, 5, 7];
+  function setupGetTest() {
+    const cache = new VolumeCache(12);
+    cache.insert("0", new Uint8Array(SLICE_0));
+    cache.insert("1", new Uint8Array(SLICE_1));
+    cache.insert("2", new Uint8Array(SLICE_2));
+    return cache;
+  }
+  describe("get", () => {
+    it("gets an entry when provided a key", () => {
+      const cache = setupGetTest();
+      const result = cache.get("1");
+      expect(result).to.deep.equal(new Uint8Array(SLICE_1));
+    });
+    it("moves returned entries to the front of the LRU queue", () => {
+      const cache = setupGetTest(); // size: 12; max: 12
+
+      cache.get("0"); // SLICE_0 moves from last to first; SLICE_1 is now last
+      cache.insert("3", new Uint8Array(SLICE_3)); // 16! evict SLICE_1
+
+      expect(cache.get("0")).to.deep.equal(new Uint8Array(SLICE_0));
+      expect(cache.get("1")).to.be.undefined;
+      expect(cache.get("2")).to.deep.equal(new Uint8Array(SLICE_2));
+      expect(cache.get("3")).to.deep.equal(new Uint8Array(SLICE_3));
+    });
+  });
+  function setupClearTest() {
+    const cache = new VolumeCache(12);
+    cache.insert("0/0", new Uint8Array(1));
+    cache.insert("0/1", new Uint8Array(2));
+    cache.insert("1/0", new Uint8Array(1));
+    return cache;
+  }
+  describe("clearWithPrefix", () => {
+    it("clears all entries from the cache whose keys have the specified prefix", () => {
+      const cache = setupClearTest();
+      cache.clearWithPrefix("0/");
+      expect(cache.size).to.equal(1);
+      expect(cache.numberOfEntries).to.equal(1);
+      expect(cache.get("0/0")).to.be.undefined;
+      expect(cache.get("0/1")).to.be.undefined;
+      expect(cache.get("1/0")).to.deep.equal(new Uint8Array(1));
+    });
+  });
+  describe("clear", () => {
+    it("clears all entries from the cache", () => {
+      const cache = setupClearTest();
+      cache.clear();
+      expect(cache.size).to.equal(0);
+      expect(cache.numberOfEntries).to.equal(0);
+      expect(cache.get("0/0")).to.be.undefined;
+      expect(cache.get("0/1")).to.be.undefined;
+      expect(cache.get("1/0")).to.be.undefined;
+    });
+  });
+});

package/es/test/VolumeRenderSettings.test.js

@@ -0,0 +1,71 @@
+import { expect } from "chai";
+import { Axis, VolumeRenderSettings } from "../VolumeRenderSettings";
+import { Vector3 } from "three";
+describe("VolumeRenderSettingUtils", () => {
+  it("deeply-copies bounds", () => {
+    const s1 = new VolumeRenderSettings();
+    const s1BMax = new Vector3(9.0, 9.0, 9.0);
+    s1.bounds.bmax = s1BMax;
+    const s2 = s1.clone();
+
+    // Values should be the same
+    expect(s1.bounds.bmax.equals(s1BMax)).to.be.true;
+    expect(s2.bounds.bmax.equals(s1BMax)).to.be.true;
+    expect(s1.isEqual(s2)).to.be.true;
+    const s2BMax = new Vector3(1.0, 2.0, 3.0);
+    s2.bounds.bmax = s2BMax;
+    expect(s2.bounds.bmax.equals(s2BMax)).to.be.true;
+    expect(s1.bounds.bmax.equals(s2BMax)).to.be.false;
+  });
+  it("deeply-copies arrays", () => {
+    const s1 = new VolumeRenderSettings();
+    const glossiness = [4.0, 3.0, 1.0];
+    s1.glossiness = glossiness;
+    const s2 = s1.clone();
+    expect(s1.glossiness).to.deep.equal(glossiness);
+    expect(s2.glossiness).to.deep.equal(glossiness);
+    s2.glossiness[1] = 17.0;
+
+    // s1 should not change.
+    expect(s1.glossiness).to.deep.equal(glossiness);
+    expect(s2.glossiness).to.deep.equal([4.0, 17.0, 1.0]);
+    expect(s1.glossiness).to.not.deep.equal(s2.glossiness);
+  });
+  it("can compare against itself", () => {
+    const s1 = new VolumeRenderSettings();
+    expect(s1.isEqual(s1)).to.be.true;
+  });
+  it("can compare settings objects", () => {
+    const s1 = new VolumeRenderSettings();
+    const s2 = new VolumeRenderSettings();
+    expect(s1.isEqual(s2)).to.be.true;
+    expect(s2.isEqual(s1)).to.be.true;
+
+    // Change boolean field
+    s2.isOrtho = !s2.isOrtho;
+    expect(s1.isEqual(s2)).to.be.false;
+    expect(s2.isEqual(s1)).to.be.false;
+
+    // Change array property
+    const s3 = new VolumeRenderSettings();
+    s3.specular[0][1] = 15;
+    expect(s1.isEqual(s3)).to.be.false;
+    expect(s3.isEqual(s1)).to.be.false;
+
+    // Change bounds
+    const s4 = new VolumeRenderSettings();
+    s4.bounds.bmax = new Vector3(-1, -2, -3);
+    expect(s1.isEqual(s4)).to.be.false;
+    expect(s4.isEqual(s1)).to.be.false;
+    s4.bounds.bmax = s1.bounds.bmax;
+    expect(s4.isEqual(s1)).to.be.true;
+    expect(s1.isEqual(s4)).to.be.true;
+  });
+  it("flags string changes", () => {
+    const s1 = new VolumeRenderSettings();
+    const s2 = new VolumeRenderSettings();
+    s1.viewAxis = Axis.NONE;
+    s2.viewAxis = Axis.X;
+    expect(s1.isEqual(s2)).to.be.false;
+  });
+});