dicom-microscopy-viewer/src/annotations/_AnnotationManager.js

Interactive web-based viewer for DICOM Microscopy Images

import dcmjs from 'dcmjs'
/** Enums */
import Enums from '../enums'
/** Utils */
import { areCodedConceptsEqual, getContentItemNameCodedConcept } from '../utils'

/** Markers */
import ArrowMarker, { _format as arrowFormat } from './markers/arrow'
import _MarkupManager from './markups/_MarkupManager'
/** Markups */
import MeasurementMarkup, {
  _format as measurementFormat,
} from './markups/measurement'
import TextEvaluationMarkup, {
  _format as textFormat,
} from './markups/textEvaluation'

const { Marker, Markup } = Enums

class _AnnotationManager {
  constructor({ map, pyramid, affine, drawingSource } = {}) {
    const markupManager = new _MarkupManager({
      map,
      pyramid,
      affine,
      drawingSource,
      formatters: {
        [Marker.Arrow]: arrowFormat,
        [Markup.Measurement]: measurementFormat,
        [Markup.TextEvaluation]: textFormat,
      },
    })

    this.props = {
      map,
      pyramid,
      affine,
      markupManager,
    }

    /** Markups */
    this[Markup.Measurement] = MeasurementMarkup(this.props)
    this[Markup.TextEvaluation] = TextEvaluationMarkup(this.props)

    /** Markers */
    this[Marker.Arrow] = ArrowMarker(this.props)
  }

  /**
   * Add markup properties based on ROI
   * measurements and evaluations.
   *
   * @param {Feature} feature The feature
   */
  _addMeasurementsAndEvaluationsProperties(feature) {
    const { measurements, evaluations } = feature.getProperties()

    if (measurements?.length) {
      return measurements.some((measurement) => {
        // eslint-disable-line
        const SUPPORTED_MEASUREMENTS_CODED_CONCEPTS = [
          new dcmjs.sr.coding.CodedConcept({
            meaning: 'Area',
            value: '42798000',
            schemeDesignator: 'SCT',
          }),
          new dcmjs.sr.coding.CodedConcept({
            meaning: 'Length',
            value: '410668003',
            schemeDesignator: 'SCT',
          }),
        ]
        const measurementCodedConcept =
          getContentItemNameCodedConcept(measurement)
        if (
          SUPPORTED_MEASUREMENTS_CODED_CONCEPTS.some((codedConcept) =>
            areCodedConceptsEqual(measurementCodedConcept, codedConcept),
          )
        ) {
          feature.set(Enums.InternalProperties.Markup, Enums.Markup.Measurement)
          return true
        }
        return false
      })
    }

    if (evaluations?.length) {
      return evaluations.some((evaluation) => {
        // eslint-disable-line
        const SUPPORTED_EVALUATIONS_CODED_CONCEPTS = [
          new dcmjs.sr.coding.CodedConcept({
            value: '112039',
            meaning: 'Tracking Identifier',
            schemeDesignator: 'DCM',
          }),
        ]
        const evaluationCodedConcept =
          getContentItemNameCodedConcept(evaluation)
        if (
          SUPPORTED_EVALUATIONS_CODED_CONCEPTS.some((codedConcept) =>
            areCodedConceptsEqual(codedConcept, evaluationCodedConcept),
          )
        ) {
          feature.set(
            Enums.InternalProperties.Markup,
            Enums.Markup.TextEvaluation,
          )
          return true
        }
        return false
      })
    }
  }

  /**
   * Sets annotations visibility.
   *
   * @param {boolean} isVisible
   */
  setVisible(isVisible) {
    this.props.markupManager.setVisible(isVisible)
  }

  /**
   * Set markup visibility.
   *
   * @param {string} id The markup id
   * @param {boolean} isVisible The markup visibility
   */
  setMarkupVisibility(id, isVisible) {
    this.props.markupManager.setVisibility(id, isVisible)
  }

  onAdd(feature) {
    /**
     * Add properties to ROI feature before triggering
     * markup and markers callbacks to keep UI in sync.
     */
    this._addMeasurementsAndEvaluationsProperties(feature)

    this[Marker.Arrow].onAdd(feature)
    this[Markup.Measurement].onAdd(feature)
    this[Markup.TextEvaluation].onAdd(feature)
  }

  onFailure(uid) {
    this[Marker.Arrow].onFailure(uid)
    this[Markup.Measurement].onFailure(uid)
    this[Markup.TextEvaluation].onFailure(uid)
  }

  onRemove(feature) {
    this[Marker.Arrow].onRemove(feature)
    this[Markup.Measurement].onRemove(feature)
    this[Markup.TextEvaluation].onRemove(feature)
  }

  onUpdate(feature) {
    this[Marker.Arrow].onUpdate(feature)
    this[Markup.Measurement].onUpdate(feature)
    this[Markup.TextEvaluation].onUpdate(feature)
  }

  onDrawStart(event) {
    this[Marker.Arrow].onDrawStart(event)
    this[Markup.Measurement].onDrawStart(event)
    this[Markup.TextEvaluation].onDrawStart(event)
  }

  onDrawEnd(event) {
    this[Marker.Arrow].onDrawEnd(event)
    this[Markup.Measurement].onDrawEnd(event)
    this[Markup.TextEvaluation].onDrawEnd(event)
    this.props.markupManager.onDrawEnd(event)
  }

  onDrawAbort(event) {
    this[Marker.Arrow].onDrawAbort(event)
    this[Markup.Measurement].onDrawAbort(event)
    this[Markup.TextEvaluation].onDrawAbort(event)
    this.props.markupManager.onDrawAbort(event)
  }
}

export default _AnnotationManager