DWVv0.37.0
tests/dicom/dicomSpatialCoordinate.test.jsjavascript
import {describe, test, assert} from 'vitest';
import {
  SpatialCoordinate,
  GraphicTypes,
  getSpatialCoordinate,
  getDicomSpatialCoordinateItem,
  getScoordFromShape,
  getShapeFromScoord
} from '../../src/dicom/dicomSpatialCoordinate.js';
import {DataElement} from '../../src/dicom/dataElement.js';
import {Point2D} from '../../src/math/point.js';
import {Line} from '../../src/math/line.js';
import {Protractor} from '../../src/math/protractor.js';
import {ROI} from '../../src/math/roi.js';
import {Circle} from '../../src/math/circle.js';
import {Ellipse} from '../../src/math/ellipse.js';
import {Rectangle} from '../../src/math/rectangle.js';
import {BidimensionalLine} from '../../src/math/bidimensionalLine.js';

/**
 * Related DICOM tag keys.
 */
const TagKeys = {
  PixelOriginInterpretation: '00480301',
  GraphicData: '00700022',
  GraphicType: '00700023',
  FiducialUID: '0070031A'
};

/**
 * Tests for the 'dicom/dicomSpatialCoordinate.js' file.
 */

describe('dicom', () => {

  describe('SpatialCoordinate', () => {

    /**
     * Tests for {@link SpatialCoordinate} undefined.
     *
     * @function module:tests/dicom~spatialcoordinateUndefined
     */
    test('undefined', () => {
      const coord = new SpatialCoordinate();
      assert.isUndefined(coord.graphicData);
      assert.isUndefined(coord.graphicType);
      assert.isUndefined(coord.pixelOriginInterpretation);
      assert.isUndefined(coord.fiducialUID);
    });

    /**
     * Tests for {@link SpatialCoordinate} toString with POINT.
     *
     * @function module:tests/dicom~spatialcoordinateTostringPoint
     */
    test('toString POINT', () => {
      const coord = new SpatialCoordinate();
      coord.graphicType = GraphicTypes.point;
      coord.graphicData = ['1.0', '2.0'];

      const result = coord.toString();
      assert.equal(result, 'POINT {1.0,2.0}');
    });

    /**
     * Tests for {@link SpatialCoordinate} toString with POLYLINE.
     *
     * @function module:tests/dicom~spatialcoordinateTostringPolyline
     */
    test('toString POLYLINE', () => {
      const coord = new SpatialCoordinate();
      coord.graphicType = GraphicTypes.polyline;
      coord.graphicData = ['1.0', '2.0', '3.0', '4.0'];

      const result = coord.toString();
      assert.equal(result, 'POLYLINE {1.0,2.0,3.0,4.0}');
    });

    /**
     * Tests for {@link SpatialCoordinate} round trip.
     *
     * @function module:tests/dicom~spatialcoordinateRoundTrip
     */
    test('round trip',
      () => {
        const deGraphicData = new DataElement('IS');
        deGraphicData.value = ['100', '200'];

        const deGraphicType = new DataElement('CS');
        deGraphicType.value = [GraphicTypes.poin];

        const dePixelOrigin = new DataElement('CS');
        dePixelOrigin.value = ['SCREEN'];

        const deFiducialUID = new DataElement('UI');
        deFiducialUID.value = ['1.2.3.4.5'];

        const dataElements = {
          [TagKeys.GraphicData]: deGraphicData,
          [TagKeys.GraphicType]: deGraphicType,
          [TagKeys.PixelOriginInterpretation]: dePixelOrigin,
          [TagKeys.FiducialUID]: deFiducialUID
        };

        const coord1 = getSpatialCoordinate(dataElements);
        const item = getDicomSpatialCoordinateItem(coord1);

        // recreate SpatialCoordinate from item
        const coord2 = new SpatialCoordinate();
        if (typeof item.GraphicData !== 'undefined') {
          coord2.graphicData = item.GraphicData;
        }
        if (typeof item.GraphicType !== 'undefined') {
          coord2.graphicType = item.GraphicType;
        }
        if (typeof item.PixelOriginInterpretation !== 'undefined') {
          coord2.pixelOriginInterpretation = item.PixelOriginInterpretation;
        }
        if (typeof item.FiducialUID !== 'undefined') {
          coord2.fiducialUID = item.FiducialUID;
        }

        // verify round-trip
        assert.deepEqual(coord1.graphicData, coord2.graphicData);
        assert.equal(coord1.graphicType, coord2.graphicType);
        assert.equal(coord1.pixelOriginInterpretation,
          coord2.pixelOriginInterpretation);
        assert.equal(coord1.fiducialUID, coord2.fiducialUID);
      }
    );

  });

  describe('getSpatialCoordinate', () => {

    /**
     * Tests for {@link getSpatialCoordinate}.
     *
     * @function module:tests/dicom~getspatialcoordinateGoodInput
     */
    test('good input', () => {
      const deGraphicData = new DataElement('IS');
      deGraphicData.value = ['100', '200'];

      const deGraphicType = new DataElement('CS');
      deGraphicType.value = [GraphicTypes.point];

      const dePixelOrigin = new DataElement('CS');
      dePixelOrigin.value = ['SCREEN'];

      const deFiducialUID = new DataElement('UI');
      deFiducialUID.value = ['1.2.3.4.5'];

      const dataElements = {
        [TagKeys.GraphicData]: deGraphicData,
        [TagKeys.GraphicType]: deGraphicType,
        [TagKeys.PixelOriginInterpretation]: dePixelOrigin,
        [TagKeys.FiducialUID]: deFiducialUID
      };

      const result = getSpatialCoordinate(dataElements);

      assert.deepEqual(result.graphicData, ['100', '200']);
      assert.equal(result.graphicType, GraphicTypes.point);
      assert.equal(result.pixelOriginInterpretation, 'SCREEN');
      assert.equal(result.fiducialUID, '1.2.3.4.5');
    });

    /**
     * Tests for {@link getSpatialCoordinate} with minimum input.
     *
     * @function module:tests/dicom~getspatialcoordinateMinimumInput
     */
    test('minimum input', () => {
      const deGraphicData = new DataElement('IS');
      deGraphicData.value = ['100', '200', '300', '400'];

      const deGraphicType = new DataElement('CS');
      deGraphicType.value = [GraphicTypes.polyline];

      const dataElements = {
        [TagKeys.GraphicData]: deGraphicData,
        [TagKeys.GraphicType]: deGraphicType
      };

      const result = getSpatialCoordinate(dataElements);

      assert.deepEqual(result.graphicData, ['100', '200', '300', '400']);
      assert.equal(result.graphicType, GraphicTypes.polyline);
      assert.isUndefined(result.pixelOriginInterpretation);
      assert.isUndefined(result.fiducialUID);
    });

    /**
     * Tests for {@link getSpatialCoordinate} with empty input.
     *
     * @function module:tests/dicom~getspatialcoordinateEmptyInput
     */
    test('empty input', () => {
      const result = getSpatialCoordinate({});

      assert.isUndefined(result.graphicData);
      assert.isUndefined(result.graphicType);
      assert.isUndefined(result.pixelOriginInterpretation);
      assert.isUndefined(result.fiducialUID);
    });

    /**
     * Tests for {@link getSpatialCoordinate} with multiple input.
     *
     * @function module:tests/dicom~getspatialcoordinateMultipleInput
     */
    test('multiple input', () => {
      const deGraphicType = new DataElement('CS');
      deGraphicType.value = [GraphicTypes.point, 'EXTRA'];

      const dataElements = {
        [TagKeys.GraphicType]: deGraphicType
      };

      const result = getSpatialCoordinate(dataElements);

      assert.equal(result.graphicType, GraphicTypes.point);
    });

  });

  describe('getDicomSpatialCoordinateItem', () => {

    /**
     * Tests for {@link getDicomSpatialCoordinateItem}.
     *
     * @function module:tests/dicom~getdicomspatialcoordinateitemGoodInput
     */
    test('good input', () => {
      const coord = new SpatialCoordinate();
      coord.graphicData = ['100', '200'];
      coord.graphicType = GraphicTypes.point;
      coord.pixelOriginInterpretation = 'SCREEN';
      coord.fiducialUID = '1.2.3.4.5';

      const item = getDicomSpatialCoordinateItem(coord);

      assert.deepEqual(item.GraphicData, ['100', '200']);
      assert.equal(item.GraphicType, GraphicTypes.point);
      assert.equal(item.PixelOriginInterpretation, 'SCREEN');
      assert.equal(item.FiducialUID, '1.2.3.4.5');
    });

    /**
     * Tests for {@link getDicomSpatialCoordinateItem} with incomplete input.
     *
     * @function module:tests/dicom~getdicomspatialcoordinateitemIncomplete
     */
    test('incomplete', () => {
      const coord = new SpatialCoordinate();
      coord.graphicType = GraphicTypes.circle;
      coord.graphicData = ['50', '50', '150', '150'];
      coord.fiducialUID = '1.2.3.4.5';

      const item = getDicomSpatialCoordinateItem(coord);

      assert.isUndefined(item.PixelOriginInterpretation);
      assert.equal(item.GraphicType, GraphicTypes.circle);
      assert.deepEqual(item.GraphicData, ['50', '50', '150', '150']);
      assert.equal(item.FiducialUID, '1.2.3.4.5');
    });

    /**
     * Tests for {@link getDicomSpatialCoordinateItem} with undefined input.
     *
     * @function module:tests/dicom~getdicomspatialcoordinateitemUndefined
     */
    test('undefined', () => {
      const coord = new SpatialCoordinate();
      const item = getDicomSpatialCoordinateItem(coord);

      assert.deepEqual(item, {});
    });

  });

  describe('getScoordFromShape', () => {

    /**
     * Tests for {@link getScoordFromShape} with Point2D.
     *
     * @function module:tests/dicom~getscoordfromshapePoint2d
     */
    test('Point2D', () => {
      const point = new Point2D(10, 20);
      const scoord = getScoordFromShape(point);

      assert.equal(scoord.graphicType, GraphicTypes.point);
      assert.equal(scoord.graphicData.length, 2);
      assert.equal(scoord.graphicData[0], '10');
      assert.equal(scoord.graphicData[1], '20');
    });

    /**
     * Tests for {@link getScoordFromShape} with Line.
     *
     * @function module:tests/dicom~getscoordfromshapeLine
     */
    test('Line', () => {
      const line = new Line(new Point2D(10, 20), new Point2D(30, 40));
      const scoord = getScoordFromShape(line);

      assert.equal(scoord.graphicType, GraphicTypes.polyline);
      assert.equal(scoord.graphicData.length, 4);
      assert.equal(scoord.graphicData[0], '10');
      assert.equal(scoord.graphicData[1], '20');
      assert.equal(scoord.graphicData[2], '30');
      assert.equal(scoord.graphicData[3], '40');
    });

    /**
     * Tests for {@link getScoordFromShape} with Circle.
     *
     * @function module:tests/dicom~getscoordfromshapeCircle
     */
    test('Circle', () => {
      const circle = new Circle(new Point2D(50, 50), 25);
      const scoord = getScoordFromShape(circle);

      assert.equal(scoord.graphicType, GraphicTypes.circle);
      assert.equal(scoord.graphicData.length, 4);
      // Center
      assert.equal(scoord.graphicData[0], '50');
      assert.equal(scoord.graphicData[1], '50');
      // Perimeter point
      assert.equal(scoord.graphicData[2], '75');
      assert.equal(scoord.graphicData[3], '50');
    });

    /**
     * Tests for {@link getScoordFromShape} with Protractor.
     *
     * @function module:tests/dicom~getscoordfromshapeProtractor
     */
    test('Protractor', () => {
      const protractor = new Protractor([
        new Point2D(10, 10),
        new Point2D(20, 20),
        new Point2D(30, 10)
      ]);
      const scoord = getScoordFromShape(protractor);

      assert.equal(scoord.graphicType, GraphicTypes.polyline);
      assert.equal(scoord.graphicData.length, 6);
      // Three points from protractor
      assert.equal(scoord.graphicData[0], '10');
      assert.equal(scoord.graphicData[1], '10');
      assert.equal(scoord.graphicData[2], '20');
      assert.equal(scoord.graphicData[3], '20');
      assert.equal(scoord.graphicData[4], '30');
      assert.equal(scoord.graphicData[5], '10');
    });

    /**
     * Tests for {@link getScoordFromShape} with ROI.
     *
     * @function module:tests/dicom~getscoordfromshapeRoi
     */
    test('ROI', () => {
      const roi = new ROI();
      roi.addPoint(new Point2D(10, 10));
      roi.addPoint(new Point2D(20, 10));
      roi.addPoint(new Point2D(20, 20));
      roi.addPoint(new Point2D(10, 20));

      const scoord = getScoordFromShape(roi);

      assert.equal(scoord.graphicType, GraphicTypes.polyline);
      // 4 points + 1 repeated first point to close = 10 coordinates
      assert.equal(scoord.graphicData.length, 10);
      // First point
      assert.equal(scoord.graphicData[0], '10');
      assert.equal(scoord.graphicData[1], '10');
      // Last point should equal first (closed shape)
      assert.equal(scoord.graphicData[8], '10');
      assert.equal(scoord.graphicData[9], '10');
    });

    /**
     * Tests for {@link getScoordFromShape} with Ellipse.
     *
     * @function module:tests/dicom~getscoordfromshapeEllipse
     */
    test('Ellipse', () => {
      const ellipse = new Ellipse(new Point2D(50, 50), 30, 20);
      const scoord = getScoordFromShape(ellipse);

      assert.equal(scoord.graphicType, GraphicTypes.ellipse);
      // 4 points (left, right, top, bottom) = 8 coordinates
      assert.equal(scoord.graphicData.length, 8);
      // Left point
      assert.equal(scoord.graphicData[0], '20');
      assert.equal(scoord.graphicData[1], '50');
      // Right point
      assert.equal(scoord.graphicData[2], '80');
      assert.equal(scoord.graphicData[3], '50');
      // Top point
      assert.equal(scoord.graphicData[4], '50');
      assert.equal(scoord.graphicData[5], '30');
      // Bottom point
      assert.equal(scoord.graphicData[6], '50');
      assert.equal(scoord.graphicData[7], '70');
    });

    /**
     * Tests for {@link getScoordFromShape} with Rectangle.
     *
     * @function module:tests/dicom~getscoordfromshapeRectangle
     */
    test('Rectangle', () => {
      const rectangle = new Rectangle(
        new Point2D(10, 10),
        new Point2D(30, 30)
      );
      const scoord = getScoordFromShape(rectangle);

      assert.equal(scoord.graphicType, GraphicTypes.polyline);
      // 4 corner points + 1 repeated first point to close = 10 coordinates
      assert.equal(scoord.graphicData.length, 10);
      // First point (top-left, begin)
      assert.equal(scoord.graphicData[0], '10');
      assert.equal(scoord.graphicData[1], '10');
      // Second point (bottom-left)
      assert.equal(scoord.graphicData[2], '10');
      assert.equal(scoord.graphicData[3], '30');
      // Third point (bottom-right, end)
      assert.equal(scoord.graphicData[4], '30');
      assert.equal(scoord.graphicData[5], '30');
      // Fourth point (top-right)
      assert.equal(scoord.graphicData[6], '30');
      assert.equal(scoord.graphicData[7], '10');
      // Last point (closed, repeated first)
      assert.equal(scoord.graphicData[8], '10');
      assert.equal(scoord.graphicData[9], '10');
    });

    /**
     * Tests for {@link getScoordFromShape} with BidimensionalLine.
     *
     * @function module:tests/dicom~getscoordfromshapeBidimensionalline
     */
    test('BidimensionalLine', () => {
      // Main axis: (10,10)-(30,10), short axis center: (20,20), length: 10
      const mainStart = new Point2D(10, 10);
      const mainEnd = new Point2D(30, 10);
      const shortAxisCenter = {x: 20, y: 20};
      const shortAxisLength = 10;
      const bline = new BidimensionalLine(mainStart, mainEnd);
      bline.shortAxisCenter = shortAxisCenter;
      bline.shortAxisLength = shortAxisLength;

      const scoord = getScoordFromShape(bline);
      assert.equal(scoord.graphicType, GraphicTypes.polyline);
      assert.equal(scoord.graphicData.length, 8);
      // Main axis
      assert.equal(scoord.graphicData[0], '10');
      assert.equal(scoord.graphicData[1], '10');
      assert.equal(scoord.graphicData[2], '30');
      assert.equal(scoord.graphicData[3], '10');
      // Short axis endpoints (should be symmetric about shortAxisCenter)
      // Just check they are numbers
      assert.ok(!isNaN(Number(scoord.graphicData[4])));
      assert.ok(!isNaN(Number(scoord.graphicData[5])));
      assert.ok(!isNaN(Number(scoord.graphicData[6])));
      assert.ok(!isNaN(Number(scoord.graphicData[7])));
    });

  });

  describe('getShapeFromScoord', () => {
    /**
     * Tests for {@link getShapeFromScoord} with BidimensionalLine polyline.
     *
     * @function module:tests/dicom~getshapefromscoordBidimensionalline
     */
    test('BidimensionalLine polyline', () => {
      // 4 points: main axis (10,10)-(30,10), short axis endpoints
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.polyline;
      // Use getScoordFromShape to generate valid data
      const mainStart = new Point2D(10, 10);
      const mainEnd = new Point2D(30, 10);
      const shortAxisCenter = {x: 20, y: 20};
      const shortAxisLength = 10;
      const bline = new BidimensionalLine(mainStart, mainEnd);
      bline.shortAxisCenter = shortAxisCenter;
      bline.shortAxisLength = shortAxisLength;
      const scoordData = getScoordFromShape(bline);
      scoord.graphicData = scoordData.graphicData;

      const shape = getShapeFromScoord(scoord);
      assert.ok(shape instanceof BidimensionalLine);
      assert.equal(shape.getBegin().getX(), 10);
      assert.equal(shape.getBegin().getY(), 10);
      assert.equal(shape.getEnd().getX(), 30);
      assert.equal(shape.getEnd().getY(), 10);
      // Check short axis properties
      assert.ok(typeof shape.shortAxisLength === 'number');
      assert.ok(typeof shape.shortAxisT === 'number');
      assert.ok(typeof shape.shortAxisL1 === 'number');
      assert.ok(typeof shape.shortAxisL2 === 'number');
      assert.ok(typeof shape.shortAxisCenter === 'object');
    });

    /**
     * Tests for {@link getShapeFromScoord} with no data.
     *
     * @function module:tests/dicom~getshapefromscoordNoData
     */
    test('no data', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.point;

      const shape = getShapeFromScoord(scoord);

      assert.isUndefined(shape);
    });

    /**
     * Tests for {@link getShapeFromScoord} with no coord.
     *
     * @function module:tests/dicom~getshapefromscoordNoCoord
     */
    test('no coord', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.poin;
      scoord.graphicData = [];

      assert.throws(() => {
        getShapeFromScoord(scoord);
      }, 'No coordinates in scoord data');
    });

    /**
     * Tests for {@link getShapeFromScoord} with odd coord.
     *
     * @function module:tests/dicom~getshapefromscoordOddCoord
     */
    test('odd coord', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.poin;
      scoord.graphicData = ['1', '2', '3'];

      assert.throws(() => {
        getShapeFromScoord(scoord);
      }, 'Expecting even number of coordinates in scoord data');
    });

    /**
     * Tests for {@link getShapeFromScoord} with point.
     *
     * @function module:tests/dicom~getshapefromscoordPoint
     */
    test('point', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.point;
      scoord.graphicData = ['10', '20'];

      const shape = getShapeFromScoord(scoord);

      assert.ok(shape instanceof Point2D);
      assert.equal(shape.getX(), 10);
      assert.equal(shape.getY(), 20);
    });

    /**
     * Tests for {@link getShapeFromScoord} with polyline 2 points.
     *
     * @function module:tests/dicom~getshapefromscoordPolyline2Points
     */
    test('polyline 2 points', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.polyline;
      scoord.graphicData = ['10', '20', '30', '40'];

      const shape = getShapeFromScoord(scoord);

      assert.ok(shape instanceof Line);
      assert.equal(shape.getBegin().getX(), 10);
      assert.equal(shape.getBegin().getY(), 20);
      assert.equal(shape.getEnd().getX(), 30);
      assert.equal(shape.getEnd().getY(), 40);
    });

    /**
     * Tests for {@link getShapeFromScoord} with circle.
     *
     * @function module:tests/dicom~getshapefromscoordCircle
     */
    test('circle', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.circle;
      scoord.graphicData = ['50', '50', '75', '50'];

      const shape = getShapeFromScoord(scoord);

      assert.ok(shape instanceof Circle);
      assert.equal(shape.getCenter().getX(), 50);
      assert.equal(shape.getCenter().getY(), 50);
      assert.equal(shape.getRadius(), 25);
    });

    /**
     * Tests for {@link getShapeFromScoord} with bad circle.
     *
     * @function module:tests/dicom~getshapefromscoordBadCircle
     */
    test('bad circle', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.circle;
      scoord.graphicData = ['50', '50'];

      assert.throws(() => {
        getShapeFromScoord(scoord);
      }, 'Expecting 2 points for circles, got 1');
    });

    /**
     * Tests for {@link getShapeFromScoord} with ellipse.
     *
     * @function module:tests/dicom~getshapefromscoordEllipse
     */
    test('ellipse', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.ellipse;
      // Left, right, top, bottom points
      scoord.graphicData = ['20', '50', '80', '50', '50', '30', '50', '70'];

      const shape = getShapeFromScoord(scoord);

      assert.ok(shape instanceof Ellipse);
      assert.equal(shape.getCenter().getX(), 50);
      assert.equal(shape.getCenter().getY(), 50);
      assert.equal(shape.getA(), 30);
      assert.equal(shape.getB(), 20);
    });

    /**
     * Tests for {@link getShapeFromScoord} with bad ellipse.
     *
     * @function module:tests/dicom~getshapefromscoordBadEllipse
     */
    test('bad ellipse', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.ellipse;
      scoord.graphicData = ['20', '50', '80', '50', '50', '30'];

      assert.throws(() => {
        getShapeFromScoord(scoord);
      }, 'Expecting 4 points for ellipses, got 3');
    });

    /**
     * Tests for {@link getShapeFromScoord} with polyline 3 points.
     *
     * @function module:tests/dicom~getshapefromscoordPolyline3Points
     */
    test('polyline 3 points', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.polyline;
      // 3 points not closed
      scoord.graphicData = ['10', '10', '20', '20', '30', '10'];

      const shape = getShapeFromScoord(scoord);

      assert.ok(shape instanceof Protractor);
      assert.equal(shape.getPoint(0).getX(), 10);
      assert.equal(shape.getPoint(0).getY(), 10);
      assert.equal(shape.getPoint(1).getX(), 20);
      assert.equal(shape.getPoint(1).getY(), 20);
      assert.equal(shape.getPoint(2).getX(), 30);
      assert.equal(shape.getPoint(2).getY(), 10);
    });

    /**
     * Tests for {@link getShapeFromScoord} with polyline 4 points.
     *
     * @function module:tests/dicom~getshapefromscoordPolyline4Points
     */
    test('polyline 4 points',
      () => {
        const scoord = new SpatialCoordinate();
        scoord.graphicType = GraphicTypes.polyline;
        // 5 points: 4 non-orthogonal corners with first point
        // repeated (closed but not rectangle)
        scoord.graphicData = [
          '10', '10', '25', '15', '30', '25', '15', '30', '10', '10'
        ];

        const shape = getShapeFromScoord(scoord);

        assert.ok(shape instanceof ROI);
        assert.equal(shape.getLength(), 4);
        assert.equal(shape.getPoint(0).getX(), 10);
        assert.equal(shape.getPoint(0).getY(), 10);
        assert.equal(shape.getPoint(1).getX(), 25);
        assert.equal(shape.getPoint(1).getY(), 15);
        assert.equal(shape.getPoint(2).getX(), 30);
        assert.equal(shape.getPoint(2).getY(), 25);
        assert.equal(shape.getPoint(3).getX(), 15);
        assert.equal(shape.getPoint(3).getY(), 30);
      }
    );

    /**
     * Tests for {@link getShapeFromScoord} with polyline 6 points.
     *
     * @function module:tests/dicom~getshapefromscoordPolyline6Points
     */
    test('polyline 6 points',
      () => {
        const scoord = new SpatialCoordinate();
        scoord.graphicType = GraphicTypes.polyline;
        // 7 points: 6 points with first repeated (closed)
        scoord.graphicData = [
          '0',
          '0',
          '10',
          '5',
          '20',
          '0',
          '25',
          '15',
          '15',
          '25',
          '5',
          '20',
          '0',
          '0'
        ];

        const shape = getShapeFromScoord(scoord);

        assert.ok(shape instanceof ROI);
        assert.equal(shape.getLength(), 6);
        assert.equal(shape.getPoint(0).getX(), 0);
        assert.equal(shape.getPoint(0).getY(), 0);
        assert.equal(shape.getPoint(5).getX(), 5);
        assert.equal(shape.getPoint(5).getY(), 20);
      }
    );

    /**
     * Tests for {@link getShapeFromScoord} with mulitpoint.
     *
     * @function module:tests/dicom~getshapefromscoordMultipoint
     */
    test('multipoint', () => {
      const scoord = new SpatialCoordinate();
      scoord.graphicType = GraphicTypes.multipoint;
      // Multiple points not closed
      scoord.graphicData = ['10', '10', '20', '20', '30', '30'];

      const shape = getShapeFromScoord(scoord);

      // multipoint type is not yet implemented, returns undefined
      assert.isUndefined(shape);
    });

  });

});