chafey / cornerstone / 68

pending completion

Build # 68

Build Type

Pull #154

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/chafey/cornerstone/commit/<a class=hub.com/chafey/cornerstone/commit/f3f122d3893f3cb1409fe577a6823ddaa706a5f8">f3f122d38<a href="https://github.com/chafey/cornerstone/commit/f3f122d3893f3cb1409fe577a6823ddaa706a5f8">&quot;&gt;Revert &amp;quot;Removing the image.decache management, which I had kept for backward compatibility but which was in any case never used since imagePromise was rejected before.&quot;

This reverts commit </a><a class="double-link" href="https://github.com/chafey/cornerstone/commit/<a class="double-link" href="https://github.com/chafey/cornerstone/commit/46e4df4cda5ac9903018ddd792ccc800b067b332">46e4df4cd</a>">46e4df4cd</a><a href="https://github.com/chafey/cornerstone/commit/f3f122d3893f3cb1409fe577a6823ddaa706a5f8">.

Pull Request Pull Request #154: Feature/imagePromise.decache

Run Details

302 of 629 branches covered (48.01%)

Branch coverage included in aggregate %.

862 of 1555 relevant lines covered (55.43%)

13.56 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.97

/src/imageCache.js

/**
 * This module deals with caching images
 */
let maximumSizeInBytes = 1024 * 1024 * 1024; // 1 GB
let cacheSizeInBytes = 0;

// Dictionary of imageId to cachedImage objects
const imageCacheDict = {};

// Array of cachedImage objects
export const cachedImages = [];

import events from './events.js';

export function setMaximumSizeBytes (numBytes) {
  if (numBytes === undefined) {
    throw new Error('setMaximumSizeBytes: parameter numBytes must not be undefined');
  }
  if (numBytes.toFixed === undefined) {
    throw new Error('setMaximumSizeBytes: parameter numBytes must be a number');
  }

  maximumSizeInBytes = numBytes;
  purgeCacheIfNecessary();
}

function purgeCacheIfNecessary () {
  // If max cache size has not been exceeded, do nothing
  if (cacheSizeInBytes <= maximumSizeInBytes) {
    return;
  }

  // Cache size has been exceeded, create list of images sorted by timeStamp
  // So we can purge the least recently used image
  function compare (a, b) {
    if (a.timeStamp > b.timeStamp) {
      return -1;
    }
    if (a.timeStamp < b.timeStamp) {
      return 1;
    }

    return 0;
  }
  cachedImages.sort(compare);

  // Remove images as necessary)
  while (cacheSizeInBytes > maximumSizeInBytes) {
    const lastCachedImage = cachedImages[cachedImages.length - 1];
    const imageId = lastCachedImage.imageId;

    removeImagePromise(imageId);

    $(events).trigger('CornerstoneImageCachePromiseRemoved', { imageId });
  }

  const cacheInfo = getCacheInfo();

  $(events).trigger('CornerstoneImageCacheFull', cacheInfo);
}

export function putImagePromise (imageId, imagePromise) {
  if (imageId === undefined) {
    throw new Error('getImagePromise: imageId must not be undefined');
  }
  if (imagePromise === undefined) {
    throw new Error('getImagePromise: imagePromise must not be undefined');
  }
  if (imageCacheDict.hasOwnProperty(imageId) === true) {
    throw new Error('putImagePromise: imageId already in cache');
  }

  const cachedImage = {
    loaded: false,
    imageId,
    sharedCacheKey: undefined, // The sharedCacheKey for this imageId.  undefined by default
    imagePromise,
    timeStamp: new Date(),
    sizeInBytes: 0
  };

  imageCacheDict[imageId] = cachedImage;
  cachedImages.push(cachedImage);

  imagePromise.then(function (image) {
    if (cachedImages.indexOf(cachedImage) === -1) {
      // If the image has been purged before being loaded, we stop here.
      return;
    }

    cachedImage.loaded = true;
    cachedImage.image = image;

    if (image.sizeInBytes === undefined) {
      throw new Error('putImagePromise: sizeInBytes must not be undefined');
    }
    if (image.sizeInBytes.toFixed === undefined) {
      throw new Error('putImagePromise: image.sizeInBytes is not a number');
    }

    cachedImage.sizeInBytes = image.sizeInBytes;
    cacheSizeInBytes += cachedImage.sizeInBytes;
    cachedImage.sharedCacheKey = image.sharedCacheKey;

    purgeCacheIfNecessary();
  });
}

export function getImagePromise (imageId) {
  if (imageId === undefined) {
    throw new Error('getImagePromise: imageId must not be undefined');
  }
  const cachedImage = imageCacheDict[imageId];

  if (cachedImage === undefined) {
    return;
  }

    // Bump time stamp for cached image
  cachedImage.timeStamp = new Date();

  return cachedImage.imagePromise;
}

export function removeImagePromise (imageId) {
  if (imageId === undefined) {
    throw new Error('removeImagePromise: imageId must not be undefined');
  }
  const cachedImage = imageCacheDict[imageId];

  if (cachedImage === undefined) {
    throw new Error('removeImagePromise: imageId was not present in imageCache');
  }

  cachedImages.splice(cachedImages.indexOf(cachedImage), 1);
  cacheSizeInBytes -= cachedImage.sizeInBytes;
  decache(cachedImage.imagePromise);

  delete imageCacheDict[imageId];
}

export function getCacheInfo () {
  return {
    maximumSizeInBytes,
    cacheSizeInBytes,
    numberOfImagesCached: cachedImages.length
  };
}

// This method should only be called by `removeImagePromise` because it's
// The one that knows how to deal with shared cache keys and cache size.
function decache (imagePromise) {
  // imagePromise.decache (cornerstone-wado-image-loader > 0.14.6)
  imagePromise.always(function () {
    if (imagePromise.decache) {
      imagePromise.decache();
    }
  });

  // image.decache (cornerstone-wado-image-loader <= 0.14.6)
  imagePromise.then(function (image) {
    if (image.decache) {
      image.decache();
    }
  });
}

export function purgeCache () {
  while (cachedImages.length > 0) {
    const removedCachedImage = cachedImages[0];

    removeImagePromise(removedCachedImage.imageId);
  }
}

export function changeImageIdCacheSize (imageId, newCacheSize) {
  const cacheEntry = imageCacheDict[imageId];

  if (cacheEntry) {
    cacheEntry.imagePromise.then(function (image) {
      const cacheSizeDifference = newCacheSize - image.sizeInBytes;

      image.sizeInBytes = newCacheSize;
      cacheEntry.sizeInBytes = newCacheSize;
      cacheSizeInBytes += cacheSizeDifference;
    });
  }
}

export default {
  imageCache: imageCacheDict,
  cachedImages,
  setMaximumSizeBytes,
  putImagePromise,
  getImagePromise,
  removeImagePromise,
  getCacheInfo,
  purgeCache,
  changeImageIdCacheSize
};

1	/**
2	* This module deals with caching images
3	*/
4	let maximumSizeInBytes = 1024 * 1024 * 1024; // 1 GB	3✔
5	let cacheSizeInBytes = 0;	3✔
6
7	// Dictionary of imageId to cachedImage objects
8	const imageCacheDict = {};	3✔
9
10	// Array of cachedImage objects
11	export const cachedImages = [];	3✔
12
13	import events from './events.js';
14
15	export function setMaximumSizeBytes (numBytes) {
16	if (numBytes === undefined) {	4✔
17	throw new Error('setMaximumSizeBytes: parameter numBytes must not be undefined');	1✔
18	}
19	if (numBytes.toFixed === undefined) {	3✔
20	throw new Error('setMaximumSizeBytes: parameter numBytes must be a number');	1✔
21	}
22
23	maximumSizeInBytes = numBytes;	2✔
24	purgeCacheIfNecessary();	2✔
25	}
26
27	function purgeCacheIfNecessary () {
28	// If max cache size has not been exceeded, do nothing
29	if (cacheSizeInBytes <= maximumSizeInBytes) {	16✔
30	return;	15✔
31	}
32
33	// Cache size has been exceeded, create list of images sorted by timeStamp
34	// So we can purge the least recently used image
35	function compare (a, b) {
36	if (a.timeStamp > b.timeStamp) {	29✔
37	return -1;	12✔
38	}
39	if (a.timeStamp < b.timeStamp) {	17!
40	return 1;	×
41	}
42
43	return 0;	17✔
44	}
45	cachedImages.sort(compare);	1✔
46
47	// Remove images as necessary)
48	while (cacheSizeInBytes > maximumSizeInBytes) {	1✔
49	const lastCachedImage = cachedImages[cachedImages.length - 1];	1✔
50	const imageId = lastCachedImage.imageId;	1✔
51
52	removeImagePromise(imageId);	1✔
53
54	$(events).trigger('CornerstoneImageCachePromiseRemoved', { imageId });	1✔
55	}
56
57	const cacheInfo = getCacheInfo();	1✔
58
59	$(events).trigger('CornerstoneImageCacheFull', cacheInfo);	1✔
60	}
61
62	export function putImagePromise (imageId, imagePromise) {
63	if (imageId === undefined) {	24✔
64	throw new Error('getImagePromise: imageId must not be undefined');	1✔
65	}
66	if (imagePromise === undefined) {	23✔
67	throw new Error('getImagePromise: imagePromise must not be undefined');	1✔
68	}
69	if (imageCacheDict.hasOwnProperty(imageId) === true) {	22✔
70	throw new Error('putImagePromise: imageId already in cache');	1✔
71	}
72
73	const cachedImage = {	21✔
74	loaded: false,
75	imageId,
76	sharedCacheKey: undefined, // The sharedCacheKey for this imageId. undefined by default
77	imagePromise,
78	timeStamp: new Date(),
79	sizeInBytes: 0
80	};
81
82	imageCacheDict[imageId] = cachedImage;	21✔
83	cachedImages.push(cachedImage);	21✔
84
85	imagePromise.then(function (image) {	21✔
86	if (cachedImages.indexOf(cachedImage) === -1) {	16!
87	// If the image has been purged before being loaded, we stop here.
88	return;	×
89	}
90
91	cachedImage.loaded = true;	16✔
92	cachedImage.image = image;	16✔
93
94	if (image.sizeInBytes === undefined) {	16✔
95	throw new Error('putImagePromise: sizeInBytes must not be undefined');	1✔
96	}
97	if (image.sizeInBytes.toFixed === undefined) {	15✔
98	throw new Error('putImagePromise: image.sizeInBytes is not a number');	1✔
99	}
100
101	cachedImage.sizeInBytes = image.sizeInBytes;	14✔
102	cacheSizeInBytes += cachedImage.sizeInBytes;	14✔
103	cachedImage.sharedCacheKey = image.sharedCacheKey;	14✔
104
105	purgeCacheIfNecessary();	14✔
106	});
107	}
108
109	export function getImagePromise (imageId) {
110	if (imageId === undefined) {	11✔
111	throw new Error('getImagePromise: imageId must not be undefined');	1✔
112	}
113	const cachedImage = imageCacheDict[imageId];	10✔
114
115	if (cachedImage === undefined) {	10✔
116	return;	6✔
117	}
118
119	// Bump time stamp for cached image
120	cachedImage.timeStamp = new Date();	4✔
121
122	return cachedImage.imagePromise;	4✔
123	}
124
125	export function removeImagePromise (imageId) {
126	if (imageId === undefined) {	11✔
127	throw new Error('removeImagePromise: imageId must not be undefined');	1✔
128	}
129	const cachedImage = imageCacheDict[imageId];	10✔
130
131	if (cachedImage === undefined) {	10✔
132	throw new Error('removeImagePromise: imageId was not present in imageCache');	1✔
133	}
134
135	cachedImages.splice(cachedImages.indexOf(cachedImage), 1);	9✔
136	cacheSizeInBytes -= cachedImage.sizeInBytes;	9✔
137	decache(cachedImage.imagePromise);	9✔
138
139	delete imageCacheDict[imageId];	9✔
140	}
141
142	export function getCacheInfo () {
143	return {	7✔
144	maximumSizeInBytes,
145	cacheSizeInBytes,
146	numberOfImagesCached: cachedImages.length
147	};
148	}
149
150	// This method should only be called by `removeImagePromise` because it's
151	// The one that knows how to deal with shared cache keys and cache size.
152	function decache (imagePromise) {
153	// imagePromise.decache (cornerstone-wado-image-loader > 0.14.6)
154	imagePromise.always(function () {	9✔
155	if (imagePromise.decache) {	4!
156	imagePromise.decache();	×
157	}
158	});
159
160	// image.decache (cornerstone-wado-image-loader <= 0.14.6)
161	imagePromise.then(function (image) {	9✔
162	if (image.decache) {	4✔
163	image.decache();	1✔
164	}
165	});
166	}
167
168	export function purgeCache () {
169	while (cachedImages.length > 0) {	17✔
170	const removedCachedImage = cachedImages[0];	7✔
171
172	removeImagePromise(removedCachedImage.imageId);	7✔
173	}
174	}
175
176	export function changeImageIdCacheSize (imageId, newCacheSize) {
177	const cacheEntry = imageCacheDict[imageId];	1✔
178
179	if (cacheEntry) {	1!
180	cacheEntry.imagePromise.then(function (image) {	1✔
181	const cacheSizeDifference = newCacheSize - image.sizeInBytes;	1✔
182
183	image.sizeInBytes = newCacheSize;	1✔
184	cacheEntry.sizeInBytes = newCacheSize;	1✔
185	cacheSizeInBytes += cacheSizeDifference;	1✔
186	});
187	}
188	}
189
190	export default {
191	imageCache: imageCacheDict,
192	cachedImages,
193	setMaximumSizeBytes,
194	putImagePromise,
195	getImagePromise,
196	removeImagePromise,
197	getCacheInfo,
198	purgeCache,
199	changeImageIdCacheSize
200	};

chafey / cornerstone / 68

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous