DWVv0.37.0
tests/gui/layerGroup.test.jsjavascript
// @vitest-environment jsdom
import {describe, test, assert, vi, afterEach} from 'vitest';
import {
  LayerGroup,
  getLayerDivId,
  getLayerDetailsFromLayerDivId,
  getLayerDetailsFromEvent,
  getScaledOffset,
} from '../../src/gui/layerGroup.js';
import {PositionBinder, WindowLevelBinder} from '../../src/gui/binders.js';
import {Stage} from '../../src/gui/stage.js';
import {Point, Point3D} from '../../src/math/point.js';
import {Index} from '../../src/math/index.js';
import {Size} from '../../src/image/size.js';
import {Spacing} from '../../src/image/spacing.js';
import {Geometry} from '../../src/image/geometry.js';
import {Image} from '../../src/image/image.js';
import {View} from '../../src/image/view.js';
import {ViewController} from '../../src/app/viewController.js';
import {getIdentityMat33} from '../../src/math/matrix.js';
import * as loggerModule from '../../src/utils/logger.js';

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

/**
 * Create a layer group mock with one view layer, as used by the
 * position binder.
 *
 * @param {string} dataId The view layer data id.
 * @param {number[]} position The view layer current position.
 * @param {number[]} size The view layer image size.
 * @param {Geometry} [geometry] The view layer image geometry.
 * @returns {{layerGroup: object, vc: object}} The layer group and its
 *   view controller.
 */
function makeBinderLayerGroup(dataId, position, size, geometry) {
  // identity orientation and origin: plane x, y are the world x, y
  const vc = {
    geometry,
    canSyncVolume: (viewController, value) =>
      typeof geometry !== 'undefined' &&
      typeof viewController.geometry !== 'undefined' &&
      geometry.canSyncVolume(viewController.geometry, value),
    getCurrentPosition: () => new Point(position),
    moreThanOne: (dim) => new Size(size).moreThanOne(dim),
    getScrollDimIndex: () => 2,
    getPlanePositionFromPosition: (point) => ({
      getX: () => point.get(0),
      getY: () => point.get(1)
    }),
    getPositionFromPlanePoint: (point2D) => {
      const values = [...position];
      values[0] = point2D.getX();
      values[1] = point2D.getY();
      return new Point(values);
    },
    setCurrentPosition: vi.fn()
  };
  const vl = {
    getViewController: () => vc,
    getDataId: () => dataId
  };
  const layerGroup = Object.assign(new EventTarget(), {
    getViewLayersByDataId: (id) => id === dataId ? [vl] : [],
    getBaseViewLayer: () => vl
  });
  return {layerGroup, vc};
}

/**
 * Fire a position change event from a source layer group to a
 * position binder of a target layer group.
 *
 * @param {PositionBinder} binder The position binder.
 * @param {object} source The source layer group mock.
 * @param {object} target The target layer group mock.
 * @param {CustomEvent} event The position change event.
 */
function firePositionEvent(binder, source, target, event) {
  source.addEventListener('positionchange', binder.getCallback(target));
  source.dispatchEvent(event);
}

/**
 * Create a geometry with volume ids.
 *
 * @param {string} name The volume id name.
 * @param {number[]} values The volume id values.
 * @returns {Geometry} The geometry.
 */
function makeVolumeGeometry(name, values) {
  const geometry = new Geometry(
    [new Point3D(0, 0, 0)],
    new Size([2, 2, 1, values.length]),
    new Spacing([1, 1, 1]));
  geometry.setVolumeIds(
    values.map(value => ({id: {value, source: name, tagKey: name}})));
  return geometry;
}

/**
 * Create a position change event.
 *
 * @param {string} dataid The source data id.
 * @param {number[]} position The source position.
 * @param {number[]} diffDims The modified dimensions.
 * @returns {CustomEvent} The event.
 */
function makePositionEvent(dataid, position, diffDims) {
  return new CustomEvent('positionchange', {
    detail: {dataid, value: [[], position], diffDims}
  });
}

/**
 * Get the position set on a view controller mock.
 *
 * @param {object} vc The view controller mock.
 * @returns {number[]} The position values.
 */
function getSetPosition(vc) {
  return vc.setCurrentPosition.mock.calls[0][0].getValues();
}

/**
 * Create a layer group mock with one view layer, as used by the
 * window/level binder.
 *
 * @param {string} dataId The view layer data id.
 * @param {string[]} presetNames The view controller preset names.
 * @returns {{layerGroup: object, vc: object}} The layer group and its
 *   view controller.
 */
function makeWindowLevelBinderLayerGroup(dataId, presetNames) {
  const vc = {
    getWindowLevelPresetsNames: () => presetNames,
    setWindowLevel: vi.fn(),
    setWindowLevelPreset: vi.fn()
  };
  const vl = {
    getViewController: () => vc
  };
  const layerGroup = {
    getViewLayersByDataId: (id) => id === dataId ? [vl] : []
  };
  return {layerGroup, vc};
}

/**
 * Create a window/level change event.
 *
 * @param {string} dataid The source data id.
 * @param {Array} value The event value: [center, width, presetName].
 * @returns {CustomEvent} The event.
 */
function makeWindowLevelEvent(dataid, value) {
  return new CustomEvent('wlchange', {
    detail: {dataid, value}
  });
}

describe('gui', () => {

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

  /**
   * Tests for {@link LayerGroup} string id.
   *
   * @function module:tests/gui~layergroupStringId
   */
  test('LayerGroup string id', () => {
    // test #00
    const theoId00 = 'layerGroupA-layer-0';
    const theoDetails00 = {groupDivId: 'layerGroupA', layerIndex: 0};
    const id00 = getLayerDivId(
      theoDetails00.groupDivId, theoDetails00.layerIndex);
    const details00 = getLayerDetailsFromLayerDivId(theoId00);
    assert.equal(id00, theoId00, 'getLayerDivId #00');
    assert.equal(details00.groupDivId, theoDetails00.groupDivId,
      'getLayerDetailsFromLayerDivId groupId #00');
    assert.equal(details00.layerIndex, theoDetails00.layerIndex,
      'getLayerDetailsFromLayerDivId layerId #00');

    // test #01
    const theoId01 = 'layerGroupB-layer-1';
    const theoDetails01 = {groupDivId: 'layerGroupB', layerIndex: 1};
    const id01 = getLayerDivId(
      theoDetails01.groupDivId, theoDetails01.layerIndex);
    const details01 = getLayerDetailsFromLayerDivId(theoId01);
    assert.equal(id01, theoId01, 'getLayerDivId #01');
    assert.equal(details01.groupDivId, theoDetails01.groupDivId,
      'getLayerDetailsFromLayerDivId groupId #01');
    assert.equal(details01.layerIndex, theoDetails01.layerIndex,
      'getLayerDetailsFromLayerDivId layerId #01');
  });

  /**
   * Tests for {@link LayerGroup} creation.
   *
   * @function module:tests/gui~layergroupCreation
   */
  test('LayerGroup creation', () => {
    const element00 = document.createElement('div');
    element00.id = 'layerGroup00';
    const layerGroup00 = new LayerGroup(element00);
    assert.equal(layerGroup00.getNumberOfLayers(), 0,
      'new layerGroup has no layers');
    assert.equal(layerGroup00.getDivId(), element00.id,
      'new layerGroup div id');
  });

  /**
   * Tests for {@link LayerGroup} add/remove view layer.
   *
   * @function module:tests/gui~layergroupAddRemoveViewLayer
   */
  test('LayerGroup add remove view layer', () => {
    const element00 = document.createElement('div');
    element00.id = 'layerGroup00';
    const layerGroup00 = new LayerGroup(element00);
    assert.equal(layerGroup00.getNumberOfLayers(), 0,
      'new layerGroup has no layers');

    const vl00 = layerGroup00.addViewLayer();
    assert.equal(layerGroup00.getNumberOfLayers(), 1,
      'layerGroup has one view layers after add');
    let activeType = typeof layerGroup00.getActiveViewLayer();
    assert.ok(activeType !== 'undefined',
      'layerGroup active view layer is defined after add');

    layerGroup00.removeLayer(vl00);
    assert.equal(layerGroup00.getNumberOfLayers(), 0,
      'layerGroup has no view layers after remove');
    activeType = typeof layerGroup00.getActiveViewLayer();
    assert.ok(activeType === 'undefined',
      'layerGroup active view layer is undefined after remove');
  });

  /**
   * Tests for {@link LayerGroup} add/remove draw layer.
   *
   * @function module:tests/gui~layergroupAddRemoveDrawLayer
   */
  test('LayerGroup add remove draw layer', () => {
    const element00 = document.createElement('div');
    element00.id = 'layerGroup00';
    const layerGroup00 = new LayerGroup(element00);
    assert.equal(layerGroup00.getNumberOfLayers(), 0,
      'new layerGroup has no layers');

    const dl00 = layerGroup00.addDrawLayer();
    assert.equal(layerGroup00.getNumberOfLayers(), 1,
      'layerGroup has one draw layers after add');
    let activeType = typeof layerGroup00.getActiveDrawLayer();
    assert.ok(activeType !== 'undefined',
      'layerGroup active draw layer is defined after add');

    layerGroup00.removeLayer(dl00);
    assert.equal(layerGroup00.getNumberOfLayers(), 0,
      'layerGroup has no draw layers after remove');
    activeType = typeof layerGroup00.getActiveDrawLayer();
    assert.ok(activeType === 'undefined',
      'layerGroup active draw layer is undefined after remove');
  });

  test('getLayerDetailsFromEvent returns null when no .layer ancestor', () => {
    const div = document.createElement('div');
    const ev = {target: div};
    assert.isNull(getLayerDetailsFromEvent(ev));
  });

  test('getLayerDetailsFromEvent extracts details from .layer', () => {
    const layerDiv = document.createElement('div');
    layerDiv.className = 'layer';
    layerDiv.id = 'layerGroup0-layer-1';
    const canvas = document.createElement('canvas');
    layerDiv.appendChild(canvas);
    document.body.appendChild(layerDiv);
    const ev = {target: canvas};
    const details = getLayerDetailsFromEvent(ev);
    assert.equal(details.groupDivId, 'layerGroup0');
    assert.equal(details.layerIndex, '1');
  });

  test('getScaledOffset keeps the center fixed under a new scale', () => {
    const offset = {x: 0, y: 0};
    const scale = {x: 1, y: 1};
    const newScale = {x: 2, y: 2};
    const center = {x: 10, y: 20};
    const result = getScaledOffset(offset, scale, newScale, center);
    // indexCenter = (center - offset) * scale = (10,20)
    // newOffset = center - indexCenter / newScale = (10-5, 20-10) = (5, 10)
    assert.equal(result.x, 5);
    assert.equal(result.y, 10);
  });

  test('LayerGroup constructor with info layer creates info layer div', () => {
    const div = document.createElement('div');
    div.id = 'lgWithInfo';
    document.body.appendChild(div);
    new LayerGroup(div, true);
    const infoDiv = div.querySelector('.infoLayer');
    assert.ok(infoDiv, 'info layer div exists');
    assert.ok(infoDiv.classList.contains('infoLayer'));
  });

  test('LayerGroup getDivId returns the container div id', () => {
    const div = document.createElement('div');
    div.id = 'myGroup';
    const lg = new LayerGroup(div);
    assert.equal(lg.getDivId(), 'myGroup');
  });

  test('LayerGroup initial scale is {x:1,y:1,z:1}', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    assert.deepEqual(lg.getScale(), {x: 1, y: 1, z: 1});
    assert.deepEqual(lg.getBaseScale(), {x: 1, y: 1, z: 1});
    assert.deepEqual(lg.getAddedScale(), {x: 1, y: 1, z: 1});
  });

  test('LayerGroup initial offset is {x:0,y:0,z:0}', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    assert.deepEqual(lg.getOffset(), {x: 0, y: 0, z: 0});
  });

  test('setScale updates the scale and fires zoomchange', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    const newScale = {x: 2, y: 2, z: 2};
    let fired = false;
    lg.addEventListener('zoomchange', (ev) => {
      fired = true;
      assert.deepEqual(ev.detail.value, [2, 2, 2]);
    });
    lg.setScale(newScale);
    assert.deepEqual(lg.getScale(), newScale);
    assert.ok(fired, 'zoomchange was fired');
  });

  test('setOffset updates the offset and fires offsetchange', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    const newOffset = {x: 10, y: 20, z: 30};
    let fired = false;
    lg.addEventListener('offsetchange', (ev) => {
      fired = true;
      assert.deepEqual(ev.detail.value, [10, 20, 30]);
    });
    lg.setOffset(newOffset);
    assert.deepEqual(lg.getOffset(), newOffset);
    assert.ok(fired, 'offsetchange was fired');
  });

  test('addTranslation shifts the offset in the opposite direction', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    lg.addTranslation({x: 3, y: 5, z: 7});
    assert.deepEqual(lg.getOffset(), {x: -3, y: -5, z: -7});
  });

  test('flipScaleZ negates the base scale z and updates scale', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    lg.flipScaleZ();
    assert.equal(lg.getBaseScale().z, -1);
    assert.equal(lg.getScale().z, -1);
  });

  test('addScale multiplies scale by (1 + step)', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    lg.addScale(0.5, {getX: () => 0, getY: () => 0, getZ: () => 0});
    assert.equal(lg.getScale().x, 1.5);
    assert.equal(lg.getScale().y, 1.5);
  });

  test('resetZoomPan restores base scale and zero offset', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    lg.setScale({x: 3, y: 3, z: 3});
    lg.setOffset({x: 10, y: 10, z: 10});
    lg.resetZoomPan();
    assert.deepEqual(lg.getScale(), {x: 1, y: 1, z: 1});
    assert.deepEqual(lg.getOffset(), {x: 0, y: 0, z: 0});
  });

  test('getAddedScale reflects scale relative to baseScale', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    lg.flipScaleZ();
    lg.setScale({x: -2, y: 2, z: -2});
    const added = lg.getAddedScale();
    assert.equal(added.z, 2);
  });

  test('shouldBind returns false with no view layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    assert.equal(lg.shouldBind(), false);
  });

  test('getMaxWorldSize returns undefined with no layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    assert.equal(typeof lg.getMaxWorldSize(), 'undefined');
  });

  test('includes returns false for undefined id', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    assert.equal(lg.includes(undefined), false);
  });

  test('includes returns true after addViewLayer', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    assert.ok(lg.includes(vl.getId()));
  });

  test('getNumberOfViewLayers counts only view layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    assert.equal(lg.getNumberOfViewLayers(), 0);
    lg.addViewLayer();
    assert.equal(lg.getNumberOfViewLayers(), 1);
    lg.addDrawLayer();
    assert.equal(lg.getNumberOfViewLayers(), 1);
  });

  test('getViewLayers returns only view layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    lg.addDrawLayer();
    const viewLayers = lg.getViewLayers();
    assert.equal(viewLayers.length, 1);
    assert.equal(viewLayers[0], vl);
  });

  test('getViewLayers filters with callback', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    lg.addViewLayer();
    assert.equal(lg.getViewLayers(() => false).length, 0);
  });

  test('getDrawLayers returns only draw layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    lg.addViewLayer();
    const dl = lg.addDrawLayer();
    const drawLayers = lg.getDrawLayers();
    assert.equal(drawLayers.length, 1);
    assert.equal(drawLayers[0], dl);
  });

  test('getDrawLayers filters with callback', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    lg.addDrawLayer();
    assert.equal(lg.getDrawLayers(() => false).length, 0);
  });

  test('getActiveViewLayer returns view layer after addViewLayer', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    assert.equal(lg.getActiveViewLayer(), vl);
  });

  test('getActiveViewLayer returns undefined for active draw layer', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    lg.addViewLayer();
    lg.addDrawLayer();
    assert.equal(typeof lg.getActiveViewLayer(), 'undefined');
  });

  test('getActiveDrawLayer returns draw layer after addDrawLayer', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const dl = lg.addDrawLayer();
    assert.equal(lg.getActiveDrawLayer(), dl);
  });

  test('getBaseViewLayer returns the first view layer', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl0 = lg.addViewLayer();
    lg.addViewLayer();
    assert.equal(lg.getBaseViewLayer(), vl0);
  });

  test('getBaseViewLayer returns undefined with no view layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    const lg = new LayerGroup(div);
    assert.equal(typeof lg.getBaseViewLayer(), 'undefined');
  });

  test('setActiveLayer fires activelayerchange event', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    const vl2 = lg.addViewLayer();
    let eventLayer;
    lg.addEventListener('activelayerchange', (ev) => {
      eventLayer = ev.detail.value[0];
    });
    lg.setActiveLayer(0);
    assert.equal(eventLayer, vl);
    lg.setActiveLayer(1);
    assert.equal(eventLayer, vl2);
  });

  test('setActiveLayerById sets the active layer by id', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl0 = lg.addViewLayer();
    const vl1 = lg.addViewLayer();
    lg.setActiveLayerById(vl0.getId());
    assert.equal(lg.getActiveViewLayer(), vl0);
    lg.setActiveLayerById(vl1.getId());
    assert.equal(lg.getActiveViewLayer(), vl1);
  });

  test('setActiveLayerByDataId sets the active layer by data id', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl0 = lg.addViewLayer();
    const vl1 = lg.addViewLayer();
    vi.spyOn(vl0, 'getDataId').mockReturnValue('data0');
    vi.spyOn(vl1, 'getDataId').mockReturnValue('data1');
    lg.setActiveLayerByDataId('data0');
    assert.equal(lg.getActiveViewLayer(), vl0);
  });

  test('getViewLayersByDataId returns matching view layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    vi.spyOn(vl, 'getDataId').mockReturnValue('data0');
    assert.deepEqual(lg.getViewLayersByDataId('data0'), [vl]);
    assert.deepEqual(lg.getViewLayersByDataId('other'), []);
  });

  test('getDrawLayersByDataId returns matching draw layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const dl = lg.addDrawLayer();
    vi.spyOn(dl, 'getDataId').mockReturnValue('data0');
    assert.deepEqual(lg.getDrawLayersByDataId('data0'), [dl]);
    assert.deepEqual(lg.getDrawLayersByDataId('other'), []);
  });

  test('getViewDataIndices returns data ids of all view layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl0 = lg.addViewLayer();
    const vl1 = lg.addViewLayer();
    vi.spyOn(vl0, 'getDataId').mockReturnValue('data0');
    vi.spyOn(vl1, 'getDataId').mockReturnValue('data1');
    assert.deepEqual(lg.getViewDataIndices(), ['data0', 'data1']);
  });

  test('setImageSmoothing propagates to view layers only', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    lg.addDrawLayer();
    const vlSpy = vi.spyOn(vl, 'setImageSmoothing');
    lg.setImageSmoothing(true);
    assert.equal(vlSpy.mock.calls.length, 1);
    assert.equal(vlSpy.mock.calls[0][0], true);
  });

  test('draw delegates to all layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    const dl = lg.addDrawLayer();
    const vlSpy = vi.spyOn(vl, 'draw').mockImplementation(() => {});
    const dlSpy = vi.spyOn(dl, 'draw').mockImplementation(() => {});
    lg.draw();
    assert.equal(vlSpy.mock.calls.length, 1);
    assert.equal(dlSpy.mock.calls.length, 1);
  });

  test('display delegates flag to all layers', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    const dl = lg.addDrawLayer();
    const vlSpy = vi.spyOn(vl, 'display').mockImplementation(() => {});
    const dlSpy = vi.spyOn(dl, 'display').mockImplementation(() => {});
    lg.display(false);
    assert.equal(vlSpy.mock.calls[0][0], false);
    assert.equal(dlSpy.mock.calls[0][0], false);
  });

  test('removeLayer fires layerremove event', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl = lg.addViewLayer();
    let eventLayerId;
    lg.addEventListener('layerremove', (ev) => {
      eventLayerId = ev.detail.layerid;
    });
    lg.removeLayer(vl);
    assert.equal(eventLayerId, vl.getId());
  });

  test('removeLayer throws when the layer is not in the group', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    lg.addViewLayer();
    assert.throws(() => lg.removeLayer({}));
  });

  test('empty clears all layers and fires layerremove for each', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    lg.addViewLayer();
    lg.addDrawLayer();
    let removeCount = 0;
    lg.addEventListener('layerremove', () => {
      removeCount++;
    });
    lg.empty();
    assert.equal(lg.getNumberOfLayers(), 0);
    assert.equal(removeCount, 2);
  });

  test('removeLayersByDataId removes layers matching the data id', () => {
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    const vl0 = lg.addViewLayer();
    const vl1 = lg.addViewLayer();
    vi.spyOn(vl0, 'getDataId').mockReturnValue('data0');
    vi.spyOn(vl1, 'getDataId').mockReturnValue('data1');
    lg.removeLayersByDataId('data0');
    assert.equal(lg.getNumberOfLayers(), 1);
    assert.equal(lg.getViewLayers()[0], vl1);
  });

  test('setShowCrosshair get/set round-trips correctly', () => {
    const warnSpy = vi.spyOn(loggerModule.logger, 'warn')
      .mockImplementation(() => {});
    const div = document.createElement('div');
    div.id = 'lg0';
    document.body.appendChild(div);
    const lg = new LayerGroup(div);
    assert.equal(lg.getShowCrosshair(), false);
    lg.setShowCrosshair(true);
    assert.equal(lg.getShowCrosshair(), true);
    assert.equal(warnSpy.mock.calls.length, 1);
    assert.equal(warnSpy.mock.calls[0][0], 'No layer to show crosshair');
    lg.setShowCrosshair(false);
    assert.equal(lg.getShowCrosshair(), false);
  });

  /**
   * Tests for {@link PositionBinder}: same data.
   *
   * @function module:tests/gui~positionBinderSameData
   */
  test('PositionBinder binds the full position of the same data', () => {
    const {layerGroup, vc} =
      makeBinderLayerGroup('data0', [0, 0, 1, 0], [2, 2, 5, 3]);
    new PositionBinder().getCallback(layerGroup)(
      makePositionEvent('data0', [1, 1, 3, 2], [2, 3]));
    assert.deepEqual(getSetPosition(vc), [1, 1, 3, 2]);
  });

  /**
   * Tests for {@link PositionBinder}: same volume id origin.
   *
   * @function module:tests/gui~positionBinderSameVolumeIdOrigin
   */
  test('PositionBinder follows the volume id of the same origin', () => {
    const source = makeBinderLayerGroup('source', [0, 0, 1, 1], [2, 2, 5, 2],
      makeVolumeGeometry('TemporalPositionIdentifier', [1, 2]));
    const target = makeBinderLayerGroup('target', [0, 0, 1, 3], [2, 2, 5, 2],
      makeVolumeGeometry('TemporalPositionIdentifier', [2, 3]));
    firePositionEvent(new PositionBinder(), source.layerGroup,
      target.layerGroup, makePositionEvent('source', [1, 1, 3, 2], [2]));
    assert.deepEqual(getSetPosition(target.vc), [1, 1, 3, 2],
      'volume id value followed');
  });

  /**
   * Tests for {@link PositionBinder}: no matching volume id.
   *
   * @function module:tests/gui~positionBinderNoMatch
   */
  test('PositionBinder keeps the volume without a matching id', () => {
    const binder = new PositionBinder();
    const source = makeBinderLayerGroup('source', [0, 0, 1, 1], [2, 2, 5, 2],
      makeVolumeGeometry('TemporalPositionIdentifier', [1, 2]));
    const other = makeBinderLayerGroup('other', [0, 0, 1, 0], [2, 2, 5, 2],
      makeVolumeGeometry('DiffusionBValue', [0, 1]));
    const targetGeometry =
      makeVolumeGeometry('TemporalPositionIdentifier', [2, 3]);
    // different origin
    const target0 = makeBinderLayerGroup('target', [0, 0, 1, 3], [2, 2, 5, 2],
      targetGeometry);
    firePositionEvent(binder, other.layerGroup, target0.layerGroup,
      makePositionEvent('other', [1, 1, 3, 1], [2]));
    assert.deepEqual(getSetPosition(target0.vc), [1, 1, 3, 3],
      'different origin');
    // same origin, value not in target
    const target1 = makeBinderLayerGroup('target', [0, 0, 1, 3], [2, 2, 5, 2],
      targetGeometry);
    firePositionEvent(binder, source.layerGroup, target1.layerGroup,
      makePositionEvent('source', [1, 1, 3, 1], [2]));
    assert.deepEqual(getSetPosition(target1.vc), [1, 1, 3, 3],
      'value not in target');
    // no source view layer
    const target2 = makeBinderLayerGroup('target', [0, 0, 1, 3], [2, 2, 5, 2],
      targetGeometry);
    binder.getCallback(target2.layerGroup)(
      makePositionEvent('source', [1, 1, 3, 2], [2]));
    assert.deepEqual(getSetPosition(target2.vc), [1, 1, 3, 3],
      'no source view layer');
  });

  /**
   * Tests for {@link PositionBinder}: volume only move.
   *
   * @function module:tests/gui~positionBinderVolumeOnlyMove
   */
  test('PositionBinder keeps the target slice on a volume only move',
    () => {
      const {layerGroup, vc} =
        makeBinderLayerGroup('data0', [0, 0, 1, 0], [2, 2, 5, 3]);
      new PositionBinder().getCallback(layerGroup)(
        makePositionEvent('data0', [1, 1, 3, 2], [3]));
      assert.deepEqual(getSetPosition(vc), [0, 0, 1, 2]);
    });

  /**
   * Tests for {@link PositionBinder}: single slice target.
   *
   * @function module:tests/gui~positionBinderSingleSlice
   */
  test('PositionBinder follows the in-plane position of a single slice ' +
    'target', () => {
    const {layerGroup, vc} =
      makeBinderLayerGroup('data0', [0, 0, 1, 0], [2, 2, 1, 3]);
    new PositionBinder().getCallback(layerGroup)(
      makePositionEvent('data0', [1, 1, 3, 2], [0, 1, 2, 3]));
    assert.deepEqual(getSetPosition(vc), [1, 1, 1, 2],
      'in-plane position followed, slice kept');
  });

  /**
   * Tests for {@link PositionBinder}: single slice target volume move.
   *
   * @function module:tests/gui~positionBinderSingleSliceVolumeMove
   */
  test('PositionBinder keeps the in-plane position of a single slice ' +
    'target on a volume only move', () => {
    const {layerGroup, vc} =
      makeBinderLayerGroup('data0', [0, 0, 1, 0], [2, 2, 1, 3]);
    new PositionBinder().getCallback(layerGroup)(
      makePositionEvent('data0', [1, 1, 3, 2], [3]));
    assert.deepEqual(getSetPosition(vc), [0, 0, 1, 2],
      'in-plane position and slice kept, volume followed');
  });

  /**
   * Tests for {@link PositionBinder}: unchanged position.
   *
   * @function module:tests/gui~positionBinderUnchanged
   */
  test('PositionBinder ignores an unchanged position', () => {
    const {layerGroup, vc} =
      makeBinderLayerGroup('data0', [0, 0, 1], [2, 2, 5]);
    const callback = new PositionBinder().getCallback(layerGroup);
    callback(makePositionEvent('data0', [1, 1, 3], []));
    assert.equal(vc.setCurrentPosition.mock.calls.length, 0,
      'unchanged position not synced');
    callback(makePositionEvent('data0', [1, 1, 3], [2]));
    assert.equal(vc.setCurrentPosition.mock.calls.length, 1,
      'changed position synced');
  });

  /**
   * Tests for {@link PositionBinder}: unchanged position of other data.
   *
   * @function module:tests/gui~positionBinderUnchangedOtherData
   */
  test('PositionBinder follows an unchanged index of other data', () => {
    // other data can have a finer grid
    const {layerGroup, vc} =
      makeBinderLayerGroup('target', [0, 0, 1], [2, 2, 5]);
    new PositionBinder().getCallback(layerGroup)(
      makePositionEvent('source', [1.5, 1, 3], []));
    assert.deepEqual(getSetPosition(vc), [1.5, 1, 3]);
  });

  /**
   * Tests for {@link PositionBinder}: target still loading.
   *
   * @function module:tests/gui~positionBinderLoading
   */
  test('PositionBinder ignores a target still loading', () => {
    const layerGroup = {
      getViewLayersByDataId: () => [],
      getBaseViewLayer: () => undefined
    };
    assert.doesNotThrow(() => new PositionBinder().getCallback(layerGroup)(
      makePositionEvent('data0', [1, 1, 3, 2], [2])));
  });

  /**
   * Tests for {@link PositionBinder}: shared event value.
   *
   * @function module:tests/gui~positionBinderEventValue
   */
  test('PositionBinder does not modify the event value', () => {
    const {layerGroup} =
      makeBinderLayerGroup('data0', [0, 0, 1, 0], [2, 2, 5, 3]);
    const event = makePositionEvent('data0', [1, 1, 3, 2], [3]);
    new PositionBinder().getCallback(layerGroup)(event);
    assert.deepEqual(event.detail.value[1], [1, 1, 3, 2]);
  });

  /**
   * Tests for {@link ViewController#canSyncVolume}, as used by the
   * position binder.
   *
   * @function module:tests/gui~viewControllerCanSyncVolume
   */
  test('ViewController canSyncVolume', () => {
    const createViewController = (geometry) => {
      const image = new Image(
        geometry, new Uint8Array(geometry.getSize().getTotalSize()));
      const view = new View(image);
      view.setOrientation(getIdentityMat33());
      return new ViewController(view);
    };
    const target = createViewController(
      makeVolumeGeometry('TemporalPositionIdentifier', [2, 3]));

    // same volume id origin
    const source = createViewController(
      makeVolumeGeometry('TemporalPositionIdentifier', [1, 2]));
    assert.ok(target.canSyncVolume(source, 2), 'value in target');
    assert.notOk(target.canSyncVolume(source, 1), 'value not in target');

    // different volume id origin
    const other = createViewController(
      makeVolumeGeometry('DiffusionBValue', [2, 3]));
    assert.notOk(target.canSyncVolume(other, 2), 'other origin');

    // no volume ids
    const noIds = createViewController(new Geometry(
      [new Point3D(0, 0, 0)], new Size([2, 2, 1]), new Spacing([1, 1, 1])));
    assert.notOk(target.canSyncVolume(noIds, 2), 'source without ids');
    assert.notOk(noIds.canSyncVolume(source, 2), 'target without ids');
  });

  /**
   * Tests for {@link PositionBinder} bound through a stage: the event is
   * dispatched by a real source layer group.
   *
   * @function module:tests/gui~positionBinderStage
   */
  test('PositionBinder syncs the volume id of stage layer groups', () => {
    const stage = new Stage();
    // add a layer group with a view layer, starting at the last volume
    const addLayerGroup = (id, volumeIds) => {
      const div = document.createElement('div');
      div.id = id;
      document.body.appendChild(div);
      const geometry = makeVolumeGeometry(
        'TemporalPositionIdentifier', volumeIds);
      const view = new View(new Image(
        geometry, new Uint8Array(geometry.getSize().getTotalSize()), ['0']));
      view.setOrientation(getIdentityMat33());
      const viewLayer = stage.addLayerGroup(div).addViewLayer();
      vi.spyOn(viewLayer, 'draw').mockImplementation(() => {});
      viewLayer.setView(view, `${id}-data`);
      const vc = viewLayer.getViewController();
      vc.setCurrentPosition(
        geometry.indexToWorld(new Index([0, 0, 0, 1])), true);
      return vc;
    };
    const sourceVc = addLayerGroup('lg0', [1, 2]);
    const targetVc = addLayerGroup('lg1', [2, 3]);
    stage.setBinders([new PositionBinder()]);

    // move the source to volume id 2: the target follows the id
    sourceVc.setCurrentPosition(new Point([1, 1, 0, 2]));
    assert.deepEqual(targetVc.getCurrentPosition().getValues(),
      [1, 1, 0, 2], 'target position');
    assert.deepEqual(targetVc.getCurrentIndex().getValues(),
      [1, 1, 0, 0], 'target volume index of the id');
  });

  /**
   * Tests for {@link WindowLevelBinder}: different data.
   *
   * @function module:tests/gui~windowLevelBinderOtherData
   */
  test('WindowLevelBinder ignores an event from different data', () => {
    const {layerGroup, vc} =
      makeWindowLevelBinderLayerGroup('data0', ['Abdomen']);
    new WindowLevelBinder().getCallback(layerGroup)(
      makeWindowLevelEvent('other', [50, 100, 'manual']));
    assert.equal(vc.setWindowLevel.mock.calls.length, 0);
    assert.equal(vc.setWindowLevelPreset.mock.calls.length, 0);
  });

  /**
   * Tests for {@link WindowLevelBinder}: no preset name.
   *
   * @function module:tests/gui~windowLevelBinderNoName
   */
  test('WindowLevelBinder sets the window level values when no preset ' +
    'name is given', () => {
    const {layerGroup, vc} =
      makeWindowLevelBinderLayerGroup('data0', ['Abdomen']);
    new WindowLevelBinder().getCallback(layerGroup)(
      makeWindowLevelEvent('data0', [50, 100]));
    assert.equal(vc.setWindowLevelPreset.mock.calls.length, 0);
    assert.equal(vc.setWindowLevel.mock.calls.length, 1);
    const wl = vc.setWindowLevel.mock.calls[0][0];
    assert.equal(wl.center, 50);
    assert.equal(wl.width, 100);
  });

  /**
   * Tests for {@link WindowLevelBinder}: 'manual' preset name.
   *
   * @function module:tests/gui~windowLevelBinderManual
   */
  test('WindowLevelBinder sets the window level values for a \'manual\' ' +
    'preset name', () => {
    // the target may already have its own (older) 'manual' preset
    const {layerGroup, vc} =
      makeWindowLevelBinderLayerGroup('data0', ['Abdomen', 'manual']);
    new WindowLevelBinder().getCallback(layerGroup)(
      makeWindowLevelEvent('data0', [50, 100, 'manual']));
    assert.equal(vc.setWindowLevelPreset.mock.calls.length, 0);
    assert.equal(vc.setWindowLevel.mock.calls.length, 1);
    const wl = vc.setWindowLevel.mock.calls[0][0];
    assert.equal(wl.center, 50);
    assert.equal(wl.width, 100);
  });

  /**
   * Tests for {@link WindowLevelBinder}: known preset name.
   *
   * @function module:tests/gui~windowLevelBinderKnownPreset
   */
  test('WindowLevelBinder sets the preset when the name is known', () => {
    const {layerGroup, vc} =
      makeWindowLevelBinderLayerGroup('data0', ['Abdomen']);
    new WindowLevelBinder().getCallback(layerGroup)(
      makeWindowLevelEvent('data0', [50, 100, 'Abdomen']));
    assert.equal(vc.setWindowLevel.mock.calls.length, 0);
    assert.equal(vc.setWindowLevelPreset.mock.calls.length, 1);
    assert.equal(vc.setWindowLevelPreset.mock.calls[0][0], 'Abdomen');
  });

  /**
   * Tests for {@link WindowLevelBinder}: unknown preset name.
   *
   * @function module:tests/gui~windowLevelBinderUnknownPreset
   */
  test('WindowLevelBinder sets the window level values for an unknown ' +
    'preset name', () => {
    const {layerGroup, vc} =
      makeWindowLevelBinderLayerGroup('data0', ['Abdomen']);
    new WindowLevelBinder().getCallback(layerGroup)(
      makeWindowLevelEvent('data0', [50, 100, 'Lung']));
    assert.equal(vc.setWindowLevelPreset.mock.calls.length, 0);
    assert.equal(vc.setWindowLevel.mock.calls.length, 1);
    const wl = vc.setWindowLevel.mock.calls[0][0];
    assert.equal(wl.center, 50);
    assert.equal(wl.width, 100);
  });

});