ohif-viewer/Packages/ohif-measurements/client/lib/jumpToRowItem.js

import { $ } from 'meteor/jquery';
import { _ } from 'meteor/underscore';
import { OHIF } from 'meteor/ohif:core';

function renderIntoViewport(viewportIndex, studyInstanceUid, seriesInstanceUid, sopInstanceUid, renderedCallback) {
    // @TypeSafeStudies
    // First, check if we already have this study loaded
    const alreadyLoadedStudy = OHIF.viewer.Studies.findBy({ studyInstanceUid });

    const { findAndRenderDisplaySet } = OHIF.measurements;
    if (alreadyLoadedStudy) {
        // If the Study is already loaded, find the display set and render it
        findAndRenderDisplaySet(alreadyLoadedStudy.displaySets, viewportIndex, studyInstanceUid, seriesInstanceUid, sopInstanceUid, renderedCallback);
    } else {
        // If not, retrieve the study metadata and then find the relevant display set and
        // render it.
        const $viewports = $('.imageViewerViewport');
        const element = $viewports.get(viewportIndex);
        const startLoadingHandler = cornerstoneTools.loadHandlerManager.getStartLoadHandler();
        startLoadingHandler(element);
        OHIF.studies.retrieveStudyMetadata(studyInstanceUid).then(study => {
            OHIF.log.warn('renderIntoViewport');

            // Double check to make sure this study wasn't already inserted
            // into OHIF.viewer.Studies, so we don't cause duplicate entry errors
            const loaded = OHIF.viewer.Studies.findBy({
                studyInstanceUid: study.studyInstanceUid
            });
            if (!loaded) {
                OHIF.viewer.Studies.insert(study);
            }

            findAndRenderDisplaySet(study.displaySets, viewportIndex, studyInstanceUid, seriesInstanceUid, sopInstanceUid, renderedCallback);
        }).catch(error => {
            OHIF.log.error(`There was an error trying to retrieve the study\'s metadata for studyInstanceUid: ${studyInstanceUid}`);
            OHIF.log.error(error.stack);

            OHIF.log.trace();
        });
    }
}

function syncViewports(viewportsIndexes) {
    const synchronizer = OHIF.viewer.stackImagePositionOffsetSynchronizer;
    const linkableViewports = synchronizer.getLinkableViewports();
    if (linkableViewports.length) {
        const linkableViewportsIndexes = _.pluck(linkableViewports, 'index');
        const indexes = _.intersection(linkableViewportsIndexes, viewportsIndexes);
        if (indexes.length) {
            OHIF.viewer.stackImagePositionOffsetSynchronizer.activateByViewportIndexes(indexes);
        }
    }
}

/**
 * Activates a set of lesions when lesion table row is clicked
 *
 * @param measurementId The unique key for a specific Measurement
 */
OHIF.measurements.jumpToRowItem = (rowItem, timepoints) => {
    OHIF.measurements.deactivateAllToolData();

    const activateMeasurements = OHIF.measurements.activateMeasurements;
    const activatedViewportIndexes = [];
    let syncViewportsCaller = syncViewports;
    let renderCount = 0;

    // Deactivate stack synchronizer because it will be re-activated later
    OHIF.viewer.stackImagePositionOffsetSynchronizer.deactivate();

    // Retrieve the timepoints that are currently being displayed in the
    // Measurement Table
    const numTimepoints = Math.max(timepoints.length, 1);

    // Retrieve the list of available viewports
    const $viewports = $('.imageViewerViewport');
    const numViewports = Math.max($viewports.length, 0);

    const numViewportsToUpdate = Math.min(numTimepoints, numViewports);

    //  Display timepoints in the order of viewports which is set by the hanging protocol
    //      Reverse the timepoint array if the first timepoint does not match with the first viewport data
    const layoutManager = OHIF.viewerbase.layoutManager;
    if (timepoints[0].studyInstanceUids.indexOf(layoutManager.viewportData[0].studyInstanceUid) < 0) {
        timepoints.reverse();
    }

    for (let i = 0; i < numViewportsToUpdate; i++) {
        const timepoint = timepoints[i];
        const timepointId = timepoint.timepointId;

        const dataAtThisTimepoint = _.where(rowItem.entries, { timepointId });
        if (!dataAtThisTimepoint || !dataAtThisTimepoint.length) {
            continue;
        }

        const measurementData = dataAtThisTimepoint[0];

        // Check if the study / series we need is already the one in the viewport
        const element = $viewports.get(i);

        activatedViewportIndexes.push(i);

        // TODO: Implement isEnabledElement in Cornerstone
        // or maybe just remove the 'error' this throws?
        let enabledElement;
        try {
            enabledElement = cornerstone.getEnabledElement(element);
        } catch(error) {
            continue;
        }

        if (enabledElement && enabledElement.image) {
            const imageId = enabledElement.image.imageId;
            const series = cornerstone.metaData.get('series', imageId);
            const study = cornerstone.metaData.get('study', imageId);

            if (series.seriesInstanceUid === measurementData.seriesInstanceUid &&
                study.studyInstanceUid === measurementData.studyInstanceUid) {

                // If it is, activate the measurements in this viewport and stop here
                activateMeasurements(element, measurementData);
                continue;
            }
        }

        // The sync will be called only after loading all series on viewports
        syncViewportsCaller = _.after(++renderCount, syncViewports);

        // Otherwise, re-render the viewport with the required study/series, then
        // add an onRendered callback to activate the measurements
        const renderedCallback = element => {
            activateMeasurements(element, measurementData);
            syncViewportsCaller(activatedViewportIndexes);
        };

        // TODO: Support frames? e.g. for measurements on multi-frame instances
        renderIntoViewport(i,
                           measurementData.studyInstanceUid,
                           measurementData.seriesInstanceUid,
                           measurementData.sopInstanceUid,
                           renderedCallback);
    }

    // If all viewports are already rendered then sync them
    if (!renderCount) {
        syncViewportsCaller(activatedViewportIndexes);
    }
};