Updates to save viewport data across sessions / while switching tabs

Packages/cornerstone/client/hangingProtocol.js

@@ -0,0 +1,45 @@
+var hangingProtocol;
+
+function defaultHangingProtocol(inputData) {
+    var studies = inputData.studies;
+    var viewportRows = inputData.viewportRows;
+    var viewportColumns = inputData.viewportColumns;
+
+    // This is the most basic hanging protocol.
+    var stacks = [];
+    studies.forEach(function(study) {
+        study.seriesList.forEach(function(series) {
+            var stack = {
+                series: series,
+                study: study
+            };
+            stacks.push(stack);
+        });
+    });
+
+    var viewportData = [];
+
+    var numViewports = viewportRows * viewportColumns;
+    for (var i=0; i < numViewports; ++i) {
+        if (i >= stacks.length) {
+            // We don't have enough stacks to fill the desired number of viewports, so stop here
+            break;
+        }
+        viewportData[i] = {
+            seriesInstanceUid: stacks[i].series.seriesInstanceUid,
+            studyInstanceUid: stacks[i].study.studyInstanceUid,
+            currentImageIdIndex: 0
+        };
+    }
+    return viewportData;
+}
+
+getHangingProtocol = function() {
+    return hangingProtocol;
+};
+
+setHangingProtocol = function(protocol) {
+    hangingProtocol = protocol;
+};
+
+setHangingProtocol(defaultHangingProtocol);

Packages/cornerstone/client/measurementManager.js

@@ -0,0 +1,77 @@
+(function($, cornerstoneTools) {
+
+    'use strict';
+
+    // This object manages a collection of measurements
+    function MeasurementManager() {
+        // Define some basic validator functions (everything is always valid)
+        this.singleMeasurementValidator = function() {
+            return {isValid: true};
+        };
+
+        this.measurementSetValidator = function() {
+            return {isValid: true};
+        };
+
+        var that = this;
+        that.measurements = [];
+
+        // adds an element as both a source and a target
+        this.add = function(measurement, validateSingle, validateSet) {
+            var index = that.measurements.push(measurement);
+
+            if (validateSingle === true) {
+                measurementValid = singleMeasurementValidator(measurement);
+            }
+
+            if (validateSet === true) {
+                measurementSetValid = measurementSetValidator(measurement);
+            }
+
+            // fire event
+            var eventDetail = {
+                index: index,
+                measurement: measurement,
+                measurementValid: measurementValid,
+                measurementSetValid: measurementSetValid
+            };
+
+            $(that).trigger('CornerstoneMeasurementAdded', eventDetail);
+        };
+
+        this.remove = function(index) {
+            var measurement = that.measurements[index];
+            that.measurements.splice(index, 1);
+            // fire event
+            var eventDetail = {
+                index: index,
+                measurement: measurement
+            };
+            $(that).trigger('CornerstoneMeasurementRemoved', eventDetail);
+        };
+
+        // Add set/get measurementValidator to run on each single measurement
+        // (e.g. length > 10 mm, location must be 30 mm from lymph node)
+        this.setSingleMeasurementValidator = function(validator) {
+            this.singleMeasurementValidator = validator;
+        };
+
+        this.getSingleMeasurementValidator = function(validator) {
+            return singleMeasurementValidator;
+        };
+
+        // Add set/get groupValidator to run on all of the measurements together
+        // (e.g. the number of measurments must be <= 2)
+        this.setMeasurementSetValidator = function(validator) {
+            this.measurementSetValidator = validator;
+        };
+
+        this.getMeasurementSetValidator = function(validator) {
+            return measurementSetValidator;
+        };
+    }
+
+    // module/private exports
+    cornerstoneTools.MeasurementManager = new MeasurementManager();
+
+})($, cornerstoneTools);

Packages/cornerstone/client/measurementManagerExample.js

@@ -0,0 +1,57 @@
+// Example usage for something like RECIST
+var tumourLengthMeasurementManager = cornerstoneTools.MeasurementManager;
+function singleValidator(measurement) {
+    var result = {
+        isValid: true
+    };
+    if (measurement.distance < 10) {
+        result.isValid = false;
+        result.details = 'Measurement distance must be less than 10 mm';
+    }
+    return result;
+}
+
+function setValidator(measurements) {
+    var result = {
+        isValid: true
+    };
+    if (measurements.length > 2) {
+        result.isValid = false;
+        result.details = 'The number of measurements per image must be less than 2';
+    }
+    return result;
+}
+
+// Or a remote call
+function remoteSetValidator(measurements) {
+    var deferred = $.Deferred;
+
+    var result = {
+        isValid: true,
+        promise: deferred.promise()
+    };
+    
+    var xhr = new XMLHttpRequest();
+    xhr.onreadystatechange = function() {
+        if (xhr.readyState == 4) {
+            if (xhr.status == 200) {
+                var response = JSON.parse(xhr.response);
+                if (response.isValid) {
+                    deferred.resolve(xhr.responseText);
+                } else {
+                    deferred.reject(xhr.responseText);
+                }
+            } else {
+                // The request didn't succeed
+                deferred.reject(xhr.responseText);
+            }
+        }
+    };
+    xhr.open("POST", "/urlToValidateRECIST", true);
+    xhr.send(measurements);
+
+    return result;
+}
+
+tumourLengthMeasurementManager.setSingleMeasurementValidator(singleValidator);
+tumourLengthMeasurementManager.setMeasurementSetValidator(setValidator);