cornerstonejs / cornerstone / 587

pending completion

Build # 587

Build Type

push

travis-ci

Committed by

diego0020

Commit Message

<a href="https://github.com/cornerstonejs/cornerstone/commit/<a class=hub.com/cornerstonejs/cornerstone/commit/6ff1a559dbc6a8ed55d43f22af0e47d8e596aa05">6ff1a559d<a href="https://github.com/cornerstonejs/cornerstone/commit/6ff1a559dbc6a8ed55d43f22af0e47d8e596aa05">&quot;&gt;Revert &amp;quot;add missing jsdocs&quot;

This reverts commit </a><a class="double-link" href="https://github.com/cornerstonejs/cornerstone/commit/<a class="double-link" href="https://github.com/cornerstonejs/cornerstone/commit/817f6d73a9ecc6a009b0733eebb33f27427c45be">817f6d73a</a>">817f6d73a</a><a href="https://github.com/cornerstonejs/cornerstone/commit/6ff1a559dbc6a8ed55d43f22af0e47d8e596aa05">.

Run Details

499 of 844 branches covered (59.12%)

Branch coverage included in aggregate %.

1303 of 1893 relevant lines covered (68.83%)

1145.19 hits per line

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

80.95

/src/rendering/renderGrayscaleImage.js

import storedPixelDataToCanvasImageData from '../internal/storedPixelDataToCanvasImageData.js';
import storedPixelDataToCanvasImageDataRGBA from '../internal/storedPixelDataToCanvasImageDataRGBA.js';
import setToPixelCoordinateSystem from '../setToPixelCoordinateSystem.js';
import now from '../internal/now.js';
import webGL from '../webgl/index.js';
import getLut from './getLut.js';
import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
import initializeRenderCanvas from './initializeRenderCanvas.js';
import saveLastRendered from './saveLastRendered.js';

function getRenderCanvas (enabledElement, image, invalidated, useAlphaChannel = true) {
  const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;

  if (!enabledElement.renderingTools.renderCanvas || canvasWasColor) {
    enabledElement.renderingTools.renderCanvas = document.createElement('canvas');
    initializeRenderCanvas(enabledElement, image);
  }

  const renderCanvas = enabledElement.renderingTools.renderCanvas;

  if (doesImageNeedToBeRendered(enabledElement, image) === false && invalidated !== true) {
    return renderCanvas;
  }

  // If our render canvas does not match the size of this image reset it
  // NOTE: This might be inefficient if we are updating multiple images of different
  // Sizes frequently.
  if (renderCanvas.width !== image.width || renderCanvas.height !== image.height) {
    initializeRenderCanvas(enabledElement, image);
  }

  // Get the lut to use
  let start = now();
  const lut = getLut(image, enabledElement.viewport, invalidated);

  image.stats = image.stats || {};
  image.stats.lastLutGenerateTime = now() - start;

  const renderCanvasData = enabledElement.renderingTools.renderCanvasData;
  const renderCanvasContext = enabledElement.renderingTools.renderCanvasContext;

  // Gray scale image - apply the lut and put the resulting image onto the render canvas
  if (useAlphaChannel) {
    storedPixelDataToCanvasImageData(image, lut, renderCanvasData.data);
  } else {
    storedPixelDataToCanvasImageDataRGBA(image, lut, renderCanvasData.data);
  }

  start = now();
  renderCanvasContext.putImageData(renderCanvasData, 0, 0);
  image.stats.lastPutImageDataTime = now() - start;

  return renderCanvas;
}

/**
 * API function to draw a grayscale image to a given enabledElement
 *
 * @param {EnabledElement} enabledElement The Cornerstone Enabled Element to redraw
 * @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
 * @returns {void}
 * @memberof rendering
 */
export function renderGrayscaleImage (enabledElement, invalidated) {
  if (enabledElement === undefined) {
    throw new Error('drawImage: enabledElement parameter must not be undefined');
  }

  const image = enabledElement.image;

  if (image === undefined) {
    throw new Error('drawImage: image must be loaded before it can be drawn');
  }

  // Get the canvas context and reset the transform
  const context = enabledElement.canvas.getContext('2d');

  context.setTransform(1, 0, 0, 1, 0, 0);

  // Clear the canvas
  context.fillStyle = 'black';
  context.fillRect(0, 0, enabledElement.canvas.width, enabledElement.canvas.height);

  // Turn off image smooth/interpolation if pixelReplication is set in the viewport
  context.imageSmoothingEnabled = !enabledElement.viewport.pixelReplication;
  context.mozImageSmoothingEnabled = context.imageSmoothingEnabled;

  // Save the canvas context state and apply the viewport properties
  setToPixelCoordinateSystem(enabledElement, context);

  let renderCanvas;

  if (enabledElement.options && enabledElement.options.renderer &&
    enabledElement.options.renderer.toLowerCase() === 'webgl') {
    // If this enabled element has the option set for WebGL, we should
    // User it as our renderer.
    renderCanvas = webGL.renderer.render(enabledElement);
  } else {
    // If no options are set we will retrieve the renderCanvas through the
    // Normal Canvas rendering path
    renderCanvas = getRenderCanvas(enabledElement, image, invalidated);
  }

  const sx = enabledElement.viewport.displayedArea.tlhc.x - 1;
  const sy = enabledElement.viewport.displayedArea.tlhc.y - 1;
  const width = enabledElement.viewport.displayedArea.brhc.x - sx;
  const height = enabledElement.viewport.displayedArea.brhc.y - sy;

  context.drawImage(renderCanvas, sx, sy, width, height, 0, 0, width, height);

  enabledElement.renderingTools = saveLastRendered(enabledElement);
}

/**
 * API function to draw a grayscale image to a given layer
 *
 * @param {EnabledElementLayer} layer The layer that the image will be added to
 * @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
 * @param {Boolean} [useAlphaChannel] - Whether or not to render the grayscale image using only the alpha channel.
                                        This does not work if this layer is not the first layer in the enabledElement.
 * @returns {void}
 */
export function addGrayscaleLayer (layer, invalidated, useAlphaChannel = false) {
  if (layer === undefined) {
    throw new Error('addGrayscaleLayer: layer parameter must not be undefined');
  }

  const image = layer.image;

  if (image === undefined) {
    throw new Error('addGrayscaleLayer: image must be loaded before it can be drawn');
  }

  layer.canvas = getRenderCanvas(layer, image, invalidated, useAlphaChannel);

  const context = layer.canvas.getContext('2d');

  // Turn off image smooth/interpolation if pixelReplication is set in the viewport
  context.imageSmoothingEnabled = !layer.viewport.pixelReplication;
  context.mozImageSmoothingEnabled = context.imageSmoothingEnabled;

  layer.renderingTools = saveLastRendered(layer);
}

1	import storedPixelDataToCanvasImageData from '../internal/storedPixelDataToCanvasImageData.js';
2	import storedPixelDataToCanvasImageDataRGBA from '../internal/storedPixelDataToCanvasImageDataRGBA.js';
3	import setToPixelCoordinateSystem from '../setToPixelCoordinateSystem.js';
4	import now from '../internal/now.js';
5	import webGL from '../webgl/index.js';
6	import getLut from './getLut.js';
7	import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
8	import initializeRenderCanvas from './initializeRenderCanvas.js';
9	import saveLastRendered from './saveLastRendered.js';
10
11	function getRenderCanvas (enabledElement, image, invalidated, useAlphaChannel = true) {	8✔
12	const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;	21✔
13
14	if (!enabledElement.renderingTools.renderCanvas \|\| canvasWasColor) {	21✔
15	enabledElement.renderingTools.renderCanvas = document.createElement('canvas');	17✔
16	initializeRenderCanvas(enabledElement, image);	17✔
17	}
18
19	const renderCanvas = enabledElement.renderingTools.renderCanvas;	21✔
20
21	if (doesImageNeedToBeRendered(enabledElement, image) === false && invalidated !== true) {	21!
22	return renderCanvas;	×
23	}
24
25	// If our render canvas does not match the size of this image reset it
26	// NOTE: This might be inefficient if we are updating multiple images of different
27	// Sizes frequently.
28	if (renderCanvas.width !== image.width \|\| renderCanvas.height !== image.height) {	21!
29	initializeRenderCanvas(enabledElement, image);	×
30	}
31
32	// Get the lut to use
33	let start = now();	21✔
34	const lut = getLut(image, enabledElement.viewport, invalidated);	21✔
35
36	image.stats = image.stats \|\| {};	21✔
37	image.stats.lastLutGenerateTime = now() - start;	21✔
38
39	const renderCanvasData = enabledElement.renderingTools.renderCanvasData;	21✔
40	const renderCanvasContext = enabledElement.renderingTools.renderCanvasContext;	21✔
41
42	// Gray scale image - apply the lut and put the resulting image onto the render canvas
43	if (useAlphaChannel) {	21✔
44	storedPixelDataToCanvasImageData(image, lut, renderCanvasData.data);	15✔
45	} else {
46	storedPixelDataToCanvasImageDataRGBA(image, lut, renderCanvasData.data);	6✔
47	}
48
49	start = now();	21✔
50	renderCanvasContext.putImageData(renderCanvasData, 0, 0);	21✔
51	image.stats.lastPutImageDataTime = now() - start;	21✔
52
53	return renderCanvas;	21✔
54	}
55
56	/**
57	* API function to draw a grayscale image to a given enabledElement
58	*
59	* @param {EnabledElement} enabledElement The Cornerstone Enabled Element to redraw
60	* @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
61	* @returns {void}
62	* @memberof rendering
63	*/
64	export function renderGrayscaleImage (enabledElement, invalidated) {
65	if (enabledElement === undefined) {	8!
66	throw new Error('drawImage: enabledElement parameter must not be undefined');	×
67	}
68
69	const image = enabledElement.image;	8✔
70
71	if (image === undefined) {	8!
72	throw new Error('drawImage: image must be loaded before it can be drawn');	×
73	}
74
75	// Get the canvas context and reset the transform
76	const context = enabledElement.canvas.getContext('2d');	8✔
77
78	context.setTransform(1, 0, 0, 1, 0, 0);	8✔
79
80	// Clear the canvas
81	context.fillStyle = 'black';	8✔
82	context.fillRect(0, 0, enabledElement.canvas.width, enabledElement.canvas.height);	8✔
83
84	// Turn off image smooth/interpolation if pixelReplication is set in the viewport
85	context.imageSmoothingEnabled = !enabledElement.viewport.pixelReplication;	8✔
86	context.mozImageSmoothingEnabled = context.imageSmoothingEnabled;	8✔
87
88	// Save the canvas context state and apply the viewport properties
89	setToPixelCoordinateSystem(enabledElement, context);	8✔
90
91	let renderCanvas;
92
93	if (enabledElement.options && enabledElement.options.renderer &&	8!
94	enabledElement.options.renderer.toLowerCase() === 'webgl') {
95	// If this enabled element has the option set for WebGL, we should
96	// User it as our renderer.
97	renderCanvas = webGL.renderer.render(enabledElement);	×
98	} else {
99	// If no options are set we will retrieve the renderCanvas through the
100	// Normal Canvas rendering path
101	renderCanvas = getRenderCanvas(enabledElement, image, invalidated);	8✔
102	}
103
104	const sx = enabledElement.viewport.displayedArea.tlhc.x - 1;	8✔
105	const sy = enabledElement.viewport.displayedArea.tlhc.y - 1;	8✔
106	const width = enabledElement.viewport.displayedArea.brhc.x - sx;	8✔
107	const height = enabledElement.viewport.displayedArea.brhc.y - sy;	8✔
108
109	context.drawImage(renderCanvas, sx, sy, width, height, 0, 0, width, height);	8✔
110
111	enabledElement.renderingTools = saveLastRendered(enabledElement);	8✔
112	}
113
114	/**
115	* API function to draw a grayscale image to a given layer
116	*
117	* @param {EnabledElementLayer} layer The layer that the image will be added to
118	* @param {Boolean} invalidated - true if pixel data has been invalidated and cached rendering should not be used
119	* @param {Boolean} [useAlphaChannel] - Whether or not to render the grayscale image using only the alpha channel.
120	This does not work if this layer is not the first layer in the enabledElement.
121	* @returns {void}
122	*/
123	export function addGrayscaleLayer (layer, invalidated, useAlphaChannel = false) {	×
124	if (layer === undefined) {	13!
125	throw new Error('addGrayscaleLayer: layer parameter must not be undefined');	×
126	}
127
128	const image = layer.image;	13✔
129
130	if (image === undefined) {	13!
131	throw new Error('addGrayscaleLayer: image must be loaded before it can be drawn');	×
132	}
133
134	layer.canvas = getRenderCanvas(layer, image, invalidated, useAlphaChannel);	13✔
135
136	const context = layer.canvas.getContext('2d');	13✔
137
138	// Turn off image smooth/interpolation if pixelReplication is set in the viewport
139	context.imageSmoothingEnabled = !layer.viewport.pixelReplication;	13✔
140	context.mozImageSmoothingEnabled = context.imageSmoothingEnabled;	13✔
141
142	layer.renderingTools = saveLastRendered(layer);	13✔
143	}

cornerstonejs / cornerstone / 587

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