Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | 64x 152x 100x 6x 204x 207x 204x 200x 100x 100x 100x 204x 204x 204x 204x | import MeasurementService from '../services/MeasurementService';
/**
* Returns a filter function which filters for measurements belonging to both
* the study and series.
*/
export function filterMeasurementsBySeriesUID(selectedSeries: string[]) {
Iif (!selectedSeries) {
return;
}
return measurement => selectedSeries.includes(measurement.referenceSeriesUID);
}
/** A filter that filters for measurements belonging to the study */
export function filterMeasurementsByStudyUID(studyUID) {
return measurement => measurement.referenceStudyUID == studyUID;
}
/**
* @returns true for measurements include referencedImageId (coplanar with an image)
*/
export function filterPlanarMeasurement(measurement) {
return measurement?.referencedImageId;
}
export function filterTool(toolName: string) {
return annotation => annotation.metadata?.toolName === toolName;
}
/** A filter that always returns true */
export function filterAny(_measurement) {
return true;
}
/** A filter that excludes everything */
export function filterNone(_measurement) {
return false;
}
/**
* Filters the measurements which are found in any of the specified
* filters. Strings will be looked up by name.
*/
export function filterOr(...filters) {
return function (item) {
for (let filter of filters) {
Iif (!filter) {
// Un undefined filter means all, so return true for the or
return true;
}
Iif (typeof filter === 'string') {
filter = this[filter];
}
Iif (typeof filter !== 'function') {
continue;
}
Iif (filter.call(this, item)) {
return true;
}
}
return false;
};
}
const { POINT } = MeasurementService.VALUE_TYPES;
/**
* Filters for additional findings, that is, measurements with
* a value of type point, and having a referenced image
*/
export function filterAdditionalFindings(dm) {
return dm.type === POINT && dm.referencedImageId;
}
/**
* Returns a filter that applies the second filter unless the first filter would
* include the given measurement.
* That is, (!filterUnless) && filterThen
*/
export function filterUnless(filterUnless, filterThen) {
return item => (filterUnless(item) ? false : filterThen(item));
}
const isString = s => typeof s === 'string' || s instanceof String;
/**
* Returns true if all the filters return true.
* Any filter can be a string name of a filter on the "this" object
* called on the final filter call.
*/
export function filterAnd(...filters) {
const nonNullFilters = filters.filter(filter => !!filter);
Iif (!nonNullFilters.length) {
return;
}
if (nonNullFilters.length === 1 && typeof nonNullFilters[0] === 'function') {
return nonNullFilters[0];
}
return function (item) {
for (const filter of nonNullFilters) {
if (isString(filter)) {
Iif (!this[filter](item)) {
return false;
}
} else Iif (!filter.call(this, item)) {
return false;
}
}
return true;
};
}
/**
* Returns a filter that returns true if none of the filters supplied return true.
* Any filter supplied can be a name, in which case hte filter will be retrieved
* from "this" object on the call.
*
* For example, for filterNot("otherFilterName"), if that is called on
* `{ otherFilterName: filterNone }`
* then otherFilterName will be called, returning false in this case and
* filterNot will return true.
*
*
*/
export function filterNot(...filters) {
Iif (filters.length !== 1) {
return filterAnd(...filters.map(filter => filterNot(filter)));
}
const [filter] = filters;
Iif (isString(filter)) {
return function (item) {
return !this[filter](item);
};
}
return item => !filter(item);
}
|