DWVv0.37.0
tests/gui/viewLayer.test.jsjavascript
// @vitest-environment jsdom
import {describe, test, assert, vi, beforeEach, afterEach} from 'vitest';
import {ViewLayer} from '../../src/gui/viewLayer.js';
import {View} from '../../src/image/view.js';
import {Image} from '../../src/image/image.js';
import {MaskImage} from '../../src/image/maskImage.js';
import {Geometry} from '../../src/image/geometry.js';
import {Size} from '../../src/image/size.js';
import {Spacing} from '../../src/image/spacing.js';
import {Point3D} from '../../src/math/point.js';
import {getIdentityMat33} from '../../src/math/matrix.js';
import {custom} from '../../src/app/custom.js';
import {CanvasSizeChecker} from '../../src/gui/generic.js';

/**
 * Tests for the 'gui/viewLayer.js' file.
 */

/**
 * Create a view layer.
 *
 * @param {boolean} isMask True to create a mask view layer.
 * @param {CanvasSizeChecker} [checker] Optional canvas size checker.
 * @returns {ViewLayer} The view layer.
 */
function createViewLayer(isMask, checker) {
  const size = new Size([2, 2, 1]);
  const geometry = new Geometry(
    [new Point3D(0, 0, 0)], size, new Spacing([1, 1, 1]));
  const buffer = new Uint8Array([0, 1, 2, 1]);
  let image;
  if (isMask) {
    image = new MaskImage(geometry, buffer, ['0']);
  } else {
    image = new Image(geometry, buffer, ['0']);
  }
  const div = document.createElement('div');
  document.body.appendChild(div);
  const viewLayer = new ViewLayer(div, checker);
  vi.spyOn(viewLayer, 'draw').mockImplementation(() => {});
  const view = new View(image);
  view.setOrientation(getIdentityMat33());
  viewLayer.setView(view, 'data0');
  return viewLayer;
}

/**
 * Get the highlight opacity of a segment.
 *
 * @param {ViewLayer} viewLayer The view layer.
 * @param {number} segmentNumber The segment number.
 * @returns {number} The segment highlight opacity.
 */
function getOpacity(viewLayer, segmentNumber) {
  const highlight = viewLayer.getViewController().getSegmentHighlight();
  if (typeof highlight === 'undefined' ||
    highlight.segmentNumber !== segmentNumber) {
    return 1;
  }
  return highlight.opacity;
}

describe('gui', () => {

  beforeEach(() => {
    vi.useFakeTimers();
  });

  afterEach(() => {
    vi.runAllTimers();
    vi.useRealTimers();
    document.body.replaceChildren();
    vi.restoreAllMocks();
  });

  test('ViewLayer highlightSegment not a mask', () => {
    const viewLayer = createViewLayer(false);
    assert.notOk(viewLayer.highlightSegment(1));
  });

  test('ViewLayer highlightSegment dim and reset', () => {
    const viewLayer = createViewLayer(true);

    assert.ok(viewLayer.highlightSegment(1, 500));

    // one pulse: minimum opacity at half duration
    vi.advanceTimersByTime(125);
    assert.isBelow(getOpacity(viewLayer, 1), 1);
    // highlight changes redraw the layer
    assert.isAbove(vi.mocked(viewLayer.draw).mock.calls.length, 0);
    vi.advanceTimersByTime(125);
    assert.closeTo(getOpacity(viewLayer, 1), 0.2, 0.05);
    vi.advanceTimersByTime(125);
    assert.isAbove(getOpacity(viewLayer, 1), 0.2);
    vi.advanceTimersByTime(175);
    // highlight is removed
    assert.isUndefined(viewLayer.getViewController().getSegmentHighlight());
  });

  test('ViewLayer highlightSegment one at a time', () => {
    const viewLayer = createViewLayer(true);

    assert.ok(viewLayer.highlightSegment(1));
    vi.advanceTimersByTime(100);
    assert.isBelow(getOpacity(viewLayer, 1), 1);
    assert.ok(viewLayer.highlightSegment(2));
    assert.equal(getOpacity(viewLayer, 1), 1);
    vi.advanceTimersByTime(100);
    assert.isBelow(getOpacity(viewLayer, 2), 1);

    // default duration (750ms): still highlighted at 600ms
    vi.advanceTimersByTime(500);
    assert.isBelow(getOpacity(viewLayer, 2), 1);
    vi.advanceTimersByTime(200);
    assert.isUndefined(viewLayer.getViewController().getSegmentHighlight());
  });

  test('ViewLayer highlightSegment custom', () => {
    const viewLayer = createViewLayer(true);
    const reset = vi.fn();
    const highlight = vi.fn(() => reset);
    custom.highlightSegment = highlight;
    try {
      assert.ok(viewLayer.highlightSegment(1, 300));
      assert.equal(highlight.mock.calls.length, 1);
      const [layer, segmentNumber, duration] = highlight.mock.calls[0];
      assert.equal(layer, viewLayer);
      assert.equal(segmentNumber, 1);
      assert.equal(duration, 300);
      // default highlight is not used
      vi.advanceTimersByTime(150);
      assert.equal(getOpacity(viewLayer, 1), 1);

      // a new highlight resets the previous one
      assert.ok(viewLayer.highlightSegment(2));
      assert.equal(reset.mock.calls.length, 1);
      assert.equal(highlight.mock.calls[1][2], 750);
    } finally {
      custom.highlightSegment = undefined;
    }
  });

  /**
   * Mock the canvas 2D context (not implemented in jsdom).
   */
  function mockCanvasContext() {
    vi.spyOn(HTMLCanvasElement.prototype, 'getContext').mockReturnValue({
      clearRect: () => {},
      fillRect: () => {},
      drawImage: () => {},
      // opaque pixel: canCreateCanvas success
      getImageData: () => ({data: [0, 0, 0, 255]}),
      createImageData: (width, height) => ({
        width,
        height,
        data: new Uint8ClampedArray(width * height * 4)
      })
    });
  }

  test('ViewLayer shares canvas size checks', () => {
    mockCanvasContext();
    const checker = new CanvasSizeChecker();
    const spy = vi.spyOn(checker, 'canCreate');
    const viewLayer0 = createViewLayer(false, checker);
    const viewLayer1 = createViewLayer(false, checker);
    viewLayer0.initialise({x: 2, y: 2}, {x: 1, y: 1}, 1);
    viewLayer1.initialise({x: 2, y: 2}, {x: 1, y: 1}, 1);
    assert.equal(spy.mock.calls.length, 2, 'Both layers use the checker');

    const createSpy = vi.spyOn(document, 'createElement');
    const getNumberOfCanvases = () => createSpy.mock.calls.filter(
      (args) => args[0] === 'canvas').length;
    const offset = {x: 0, y: 0};
    // first layer: tested
    viewLayer0.fitToContainer({x: 20, y: 20}, 1, offset);
    const count = getNumberOfCanvases();
    assert.ok(count > 0, 'First layer size is tested');
    // second layer, same size: cached
    viewLayer1.fitToContainer({x: 20, y: 20}, 1, offset);
    assert.equal(getNumberOfCanvases(), count,
      'Second layer uses the shared cache');
  });

  test('ViewLayer onimagegeometrychange fires basesizechange', () => {
    mockCanvasContext();
    const viewLayer = createViewLayer(false);
    // base size smaller than the 2x2 image: as when the layer is
    // created at first load item for a non acquisition orientation
    viewLayer.initialise({x: 2, y: 1}, {x: 1, y: 1}, 1);
    const listener = vi.fn();
    viewLayer.addEventListener('basesizechange', listener);

    viewLayer.onimagegeometrychange(new CustomEvent('imagegeometrychange'));
    assert.equal(listener.mock.calls.length, 1);
    const detail = listener.mock.calls[0][0].detail;
    assert.deepEqual(detail.value, [2, 2]);
    assert.equal(detail.dataid, 'data0');
    assert.deepEqual(viewLayer.getBaseSize(), {x: 2, y: 2});

    // same size: no event
    viewLayer.onimagegeometrychange(new CustomEvent('imagegeometrychange'));
    assert.equal(listener.mock.calls.length, 1);
  });

});