chore(docs): Add missing jsdocs to the rendering module (#315)

* add missing jsdocs

* eslint-fix

* restore .babelrc

Author: diego0020

Diff for: .babelrc

@@ -1,3 +1,5 @@
 {
-  "presets": ["@babel/preset-env"]
-}
+  "presets": [
+    "@babel/preset-env"
+  ]
+}

Diff for: src/rendering/getLut.js

@@ -10,6 +10,7 @@ import generateLut from '../internal/generateLut.js';
  * @param {Boolean} invalidated Whether or not the LUT data has been invalidated
  * (e.g. by a change to the windowWidth, windowCenter, or invert viewport parameters).
  * @return {Uint8ClampedArray} LUT Array
+ * @memberof rendering
  */
 export default function (image, viewport, invalidated) {
   // If we have a cached lut and it has the right values, return it immediately

Diff for: src/rendering/initializeRenderCanvas.js

@@ -1,3 +1,11 @@
+/**
+ * Sets size and clears canvas
+ *
+ * @param {Object} enabledElement Cornerstone Enabled Element
+ * @param {Object} image Image to be rendered
+ * @returns {void}
+ * @memberof rendering
+ */
 export default function (enabledElement, image) {
   const renderCanvas = enabledElement.renderingTools.renderCanvas;
 

Diff for: src/rendering/renderColorImage.js

@@ -8,12 +8,21 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import initializeRenderCanvas from './initializeRenderCanvas.js';
 import saveLastRendered from './saveLastRendered.js';
 
+/**
+ * Generates an appropriate Look Up Table to render the given image with the given window width and level (specified in the viewport)
+ * Uses an internal cache for performance
+ *
+ * @param {Object} image  The image to be rendered
+ * @param {Object} viewport The viewport values used for rendering
+ * @returns {Uint8ClampedArray} Look Up Table array.
+ * @memberof rendering
+ */
 function getLut (image, viewport) {
   // If we have a cached lut and it has the right values, return it immediately
   if (image.cachedLut !== undefined &&
-        image.cachedLut.windowCenter === viewport.voi.windowCenter &&
-        image.cachedLut.windowWidth === viewport.voi.windowWidth &&
-        image.cachedLut.invert === viewport.invert) {
+    image.cachedLut.windowCenter === viewport.voi.windowCenter &&
+    image.cachedLut.windowWidth === viewport.voi.windowWidth &&
+    image.cachedLut.invert === viewport.invert) {
     return image.cachedLut.lutArray;
   }
 
@@ -26,6 +35,16 @@ function getLut (image, viewport) {
   return image.cachedLut.lutArray;
 }
 
+/**
+ * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
+ * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
+ *
+ * @param {Object} enabledElement The cornerstone enabled element
+ * @param {Object} image The image to be rendered
+ * @param {Boolean} invalidated Is pixel data valid
+ * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
+ * @memberof rendering
+ */
 function getRenderCanvas (enabledElement, image, invalidated) {
   const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;
 
@@ -38,10 +57,10 @@ function getRenderCanvas (enabledElement, image, invalidated) {
   // The ww/wc is identity and not inverted - get a canvas with the image rendered into it for
   // Fast drawing
   if (enabledElement.viewport.voi.windowWidth === 255 &&
-        enabledElement.viewport.voi.windowCenter === 128 &&
-        enabledElement.viewport.invert === false &&
-        image.getCanvas &&
-        image.getCanvas()
+    enabledElement.viewport.voi.windowCenter === 128 &&
+    enabledElement.viewport.invert === false &&
+    image.getCanvas &&
+    image.getCanvas()
   ) {
     return image.getCanvas();
   }

Diff for: src/rendering/renderGrayscaleImage.js

@@ -8,6 +8,17 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import initializeRenderCanvas from './initializeRenderCanvas.js';
 import saveLastRendered from './saveLastRendered.js';
 
+/**
+ * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
+ * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
+ *
+ * @param {Object} enabledElement The cornerstone enabled element
+ * @param {Object} image The image to be rendered
+ * @param {Boolean} invalidated Is pixel data valid
+ * @param {Boolean} [useAlphaChannel = true] Will an alpha channel be used
+ * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
+ * @memberof rendering
+ */
 function getRenderCanvas (enabledElement, image, invalidated, useAlphaChannel = true) {
   const canvasWasColor = enabledElement.renderingTools.lastRenderedIsColor === true;
 

Diff for: src/rendering/renderLabelMapImage.js

@@ -6,6 +6,16 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import storedPixelDataToCanvasImageDataColorLUT from '../internal/storedPixelDataToCanvasImageDataColorLUT.js';
 import colors from '../colors/index.js';
 
+/**
+ * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
+ * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
+ *
+ * @param {Object} enabledElement The cornerstone enabled element
+ * @param {Object} image The image to be rendered
+ * @param {Boolean} invalidated Is pixel data valid
+ * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
+ * @memberof rendering
+ */
 function getRenderCanvas (enabledElement, image, invalidated) {
   if (!enabledElement.renderingTools.renderCanvas) {
     enabledElement.renderingTools.renderCanvas = document.createElement('canvas');

Diff for: src/rendering/renderPseudoColorImage.js

@@ -7,6 +7,16 @@ import doesImageNeedToBeRendered from './doesImageNeedToBeRendered.js';
 import storedPixelDataToCanvasImageDataPseudocolorLUT from '../internal/storedPixelDataToCanvasImageDataPseudocolorLUT.js';
 import colors from '../colors/index.js';
 
+/**
+ * Returns an appropriate canvas to render the Image. If the canvas available in the cache is appropriate
+ * it is returned, otherwise adjustments are made. It also sets the color transfer functions.
+ *
+ * @param {Object} enabledElement The cornerstone enabled element
+ * @param {Object} image The image to be rendered
+ * @param {Boolean} invalidated Is pixel data valid
+ * @returns {HTMLCanvasElement} An appropriate canvas for rendering the image
+ * @memberof rendering
+ */
 function getRenderCanvas (enabledElement, image, invalidated) {
   if (!enabledElement.renderingTools.renderCanvas) {
     enabledElement.renderingTools.renderCanvas = document.createElement('canvas');
@@ -45,7 +55,7 @@ function getRenderCanvas (enabledElement, image, invalidated) {
   let start = now();
 
   if (!enabledElement.renderingTools.colorLut || invalidated ||
-       enabledElement.renderingTools.colormapId !== colormapId) {
+    enabledElement.renderingTools.colormapId !== colormapId) {
     colormap.setNumberOfColors(256);
     enabledElement.renderingTools.colorLut = colormap.createLookupTable();
     enabledElement.renderingTools.colormapId = colormapId;

Diff for: src/rendering/renderToCanvas.js

@@ -4,15 +4,29 @@ import drawImageSync from '../internal/drawImageSync.js';
 import getDefaultViewport from '../internal/getDefaultViewport.js';
 import tryEnableWebgl from '../internal/tryEnableWebgl.js';
 
+/**
+ * @typedef {Object} EnabledElementStub
+ * @property {HTMLElement} element  The enabled element
+ * @property {HTMLCanvasElement} canvas The current canvas
+ * @property {Object} image Currently displayed image
+ * @property {Boolean} invalid Whether or not the image pixel data has been changed
+ * @property {Boolean} needsRedraw  A flag for triggering a redraw of the canvas without re-retrieving the pixel data, since it remains valid
+ * @property {Object} options Layer drawing options
+ * @property {Object[]} layers Layers added to the EnabledElement
+ * @property {Object} data
+ * @property {Object} renderingTools
+ * @property {Object} viewport The current viewport
+ * @memberof rendering
+ */
 
 /**
  * creates a dummy enabled element
  *
- * @param {any} canvas the canvas that will be assigned to the enabled element.
+ * @param {HTMLCanvasElement} canvas the canvas that will be assigned to the enabled element.
  * @param {any} image An Image loaded by a Cornerstone Image Loader
  * @param { any } options Options for rendering the image (e.g.enable webgl by {renderer: 'webgl' })
  * @param { any } viewport A set of Cornerstone viewport parameters
- * @returns { element, canvas,image, invalid: Boolean, needsRedraw: Booleans, options, layers: [], data, renderingTools, viewport} a dummy enabled element
+ * @returns {EnabledElementStub} a dummy enabled element
  * @memberof rendering
  */
 function createEnabledElementStub (canvas, image, options, viewport) {
@@ -34,8 +48,8 @@ function createEnabledElementStub (canvas, image, options, viewport) {
  * Render the image to the provided canvas immediately.
  * @param {any} canvas The HTML canvas where the image will be rendered.
  * @param {any} image An Image loaded by a Cornerstone Image Loader
- * @param {any} viewport A set of Cornerstone viewport parameters
- * @param {any} options Options for rendering the image (e.g. enable webgl by {renderer: 'webgl'})
+ * @param {any} [viewport = null] A set of Cornerstone viewport parameters
+ * @param {any} [options = null] Options for rendering the image (e.g. enable webgl by {renderer: 'webgl'})
  * @returns {void}
  * @memberof rendering
  */

Diff for: src/rendering/saveLastRendered.js

@@ -1,3 +1,11 @@
+/**
+ * Saves the parameters of the last render into renderingTools, used later to decide if data can be reused.
+ *
+ * @param {Object} enabledElement Cornerstone EnabledElement
+ * @returns {Object} enabledElement.renderingTools
+ * @memberof rendering
+ */
+
 export default function (enabledElement) {
   const imageId = enabledElement.image.imageId;
   const viewport = enabledElement.viewport;