mcarman
/
React_Client_App_Access
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
3 коммитов
1 ветка
84 MiB
 
 
 
 
Дерево: 93fc9f155b
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из '93fc9f155b'
${ noResults }
React_Client_App_Access/node_modules/stackblur-canvas/docs/jsdoc/stackblur.js.html

707 строки
21 KiB
Исходник Вина История 

  1. <!DOCTYPE html>

  2. <html lang="en">

  3. <head>

  4.     <meta charset="utf-8">

  5.     <title>JSDoc: Source: stackblur.js</title>

  6. 

  7.     <script src="scripts/prettify/prettify.js"> </script>

  8.     <script src="scripts/prettify/lang-css.js"> </script>

  9.     <!--[if lt IE 9]>

  10.       <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>

  11.     <![endif]-->

  12.     <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">

  13.     <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">

  14. </head>

  15. 

  16. <body>

  17. 

  18. <div id="main">

  19. 

  20.     <h1 class="page-title">Source: stackblur.js</h1>

  21. 

  22.     

  23. 

  24. 

  25. 

  26.     

  27.     <section>

  28.         <article>

  29.             <pre class="prettyprint source linenums"><code>/**

  30. * StackBlur - a fast almost Gaussian Blur For Canvas

  31. *

  32. * In case you find this class useful - especially in commercial projects -

  33. * I am not totally unhappy for a small donation to my PayPal account

  34. * mario@quasimondo.de

  35. *

  36. * Or support me on flattr:

  37. * {@link https://flattr.com/thing/72791/StackBlur-a-fast-almost-Gaussian-Blur-Effect-for-CanvasJavascript}

  38. * @module StackBlur

  39. * @version 0.5

  40. * @author Mario Klingemann

  41. * Contact: mario@quasimondo.com

  42. * Website: {@link http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html}

  43. * Twitter: @quasimondo

  44. *

  45. * @copyright (c) 2010 Mario Klingemann

  46. *

  47. * Permission is hereby granted, free of charge, to any person

  48. * obtaining a copy of this software and associated documentation

  49. * files (the "Software"), to deal in the Software without

  50. * restriction, including without limitation the rights to use,

  51. * copy, modify, merge, publish, distribute, sublicense, and/or sell

  52. * copies of the Software, and to permit persons to whom the

  53. * Software is furnished to do so, subject to the following

  54. * conditions:

  55. *

  56. * The above copyright notice and this permission notice shall be

  57. * included in all copies or substantial portions of the Software.

  58. *

  59. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

  60. * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

  61. * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

  62. * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

  63. * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

  64. * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

  65. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

  66. * OTHER DEALINGS IN THE SOFTWARE.

  67. */

  68. 

  69. const mulTable = [

  70.     512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512,

  71.     454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512,

  72.     482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456,

  73.     437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512,

  74.     497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328,

  75.     320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456,

  76.     446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335,

  77.     329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512,

  78.     505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405,

  79.     399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328,

  80.     324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271,

  81.     268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456,

  82.     451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388,

  83.     385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335,

  84.     332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292,

  85.     289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259];

  86. 

  87. const shgTable = [

  88.     9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17,

  89.     17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19,

  90.     19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20,

  91.     20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,

  92.     21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,

  93.     21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22,

  94.     22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,

  95.     22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23,

  96.     23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,

  97.     23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,

  98.     23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,

  99.     23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,

  100.     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,

  101.     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,

  102.     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,

  103.     24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24];

  104. 

  105. /**

  106.  * @param {string|HTMLImageElement} img

  107.  * @param {string|HTMLCanvasElement} canvas

  108.  * @param {Float} radius

  109.  * @param {boolean} blurAlphaChannel

  110.  * @returns {undefined}

  111.  */

  112. function processImage (img, canvas, radius, blurAlphaChannel) {

  113.     if (typeof img === 'string') {

  114.         img = document.getElementById(img);

  115.     }

  116.     if (!img || !('naturalWidth' in img)) {

  117.         return;

  118.     }

  119.     const w = img.naturalWidth;

  120.     const h = img.naturalHeight;

  121. 

  122.     if (typeof canvas === 'string') {

  123.         canvas = document.getElementById(canvas);

  124.     }

  125.     if (!canvas || !('getContext' in canvas)) {

  126.         return;

  127.     }

  128. 

  129.     canvas.style.width = w + 'px';

  130.     canvas.style.height = h + 'px';

  131.     canvas.width = w;

  132.     canvas.height = h;

  133. 

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

  135.     context.clearRect(0, 0, w, h);

  136.     context.drawImage(img, 0, 0);

  137. 

  138.     if (isNaN(radius) || radius &lt; 1) { return; }

  139. 

  140.     if (blurAlphaChannel) {

  141.         processCanvasRGBA(canvas, 0, 0, w, h, radius);

  142.     } else {

  143.         processCanvasRGB(canvas, 0, 0, w, h, radius);

  144.     }

  145. }

  146. 

  147. /**

  148.  * @param {string|HTMLCanvasElement} canvas

  149.  * @param {Integer} topX

  150.  * @param {Integer} topY

  151.  * @param {Integer} width

  152.  * @param {Integer} height

  153.  * @throws {Error|TypeError}

  154.  * @returns {ImageData} See {@link https://html.spec.whatwg.org/multipage/canvas.html#imagedata}

  155.  */

  156. function getImageDataFromCanvas (canvas, topX, topY, width, height) {

  157.     if (typeof canvas === 'string') {

  158.         canvas = document.getElementById(canvas);

  159.     }

  160.     if (!canvas || typeof canvas !== 'object' || !('getContext' in canvas)) {

  161.         throw new TypeError('Expecting canvas with `getContext` method in processCanvasRGB(A) calls!');

  162.     }

  163. 

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

  165. 

  166.     try {

  167.         return context.getImageData(topX, topY, width, height);

  168.     } catch (e) {

  169.         throw new Error('unable to access image data: ' + e);

  170.     }

  171. }

  172. 

  173. /**

  174.  * @param {HTMLCanvasElement} canvas

  175.  * @param {Integer} topX

  176.  * @param {Integer} topY

  177.  * @param {Integer} width

  178.  * @param {Integer} height

  179.  * @param {Float} radius

  180.  * @returns {undefined}

  181.  */

  182. function processCanvasRGBA (canvas, topX, topY, width, height, radius) {

  183.     if (isNaN(radius) || radius &lt; 1) { return; }

  184.     radius |= 0;

  185. 

  186.     let imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);

  187. 

  188.     imageData = processImageDataRGBA(imageData, topX, topY, width, height, radius);

  189. 

  190.     canvas.getContext('2d').putImageData(imageData, topX, topY);

  191. }

  192. 

  193. /**

  194.  * @param {ImageData} imageData

  195.  * @param {Integer} topX

  196.  * @param {Integer} topY

  197.  * @param {Integer} width

  198.  * @param {Integer} height

  199.  * @param {Float} radius

  200.  * @returns {ImageData}

  201.  */

  202. function processImageDataRGBA (imageData, topX, topY, width, height, radius) {

  203.     const pixels = imageData.data;

  204. 

  205.     let x, y, i, p, yp, yi, yw, rSum, gSum, bSum, aSum,

  206.         rOutSum, gOutSum, bOutSum, aOutSum,

  207.         rInSum, gInSum, bInSum, aInSum,

  208.         pr, pg, pb, pa, rbs;

  209. 

  210.     const div = 2 * radius + 1;

  211.     // const w4 = width &lt;&lt; 2;

  212.     const widthMinus1 = width - 1;

  213.     const heightMinus1 = height - 1;

  214.     const radiusPlus1 = radius + 1;

  215.     const sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;

  216. 

  217.     const stackStart = new BlurStack();

  218.     let stack = stackStart;

  219.     let stackEnd;

  220.     for (i = 1; i &lt; div; i++) {

  221.         stack = stack.next = new BlurStack();

  222.         if (i === radiusPlus1) {

  223.             stackEnd = stack;

  224.         }

  225.     }

  226.     stack.next = stackStart;

  227.     let stackIn = null;

  228.     let stackOut = null;

  229. 

  230.     yw = yi = 0;

  231. 

  232.     const mulSum = mulTable[radius];

  233.     const shgSum = shgTable[radius];

  234. 

  235.     for (y = 0; y &lt; height; y++) {

  236.         rInSum = gInSum = bInSum = aInSum = rSum = gSum = bSum = aSum = 0;

  237. 

  238.         rOutSum = radiusPlus1 * (pr = pixels[yi]);

  239.         gOutSum = radiusPlus1 * (pg = pixels[yi + 1]);

  240.         bOutSum = radiusPlus1 * (pb = pixels[yi + 2]);

  241.         aOutSum = radiusPlus1 * (pa = pixels[yi + 3]);

  242. 

  243.         rSum += sumFactor * pr;

  244.         gSum += sumFactor * pg;

  245.         bSum += sumFactor * pb;

  246.         aSum += sumFactor * pa;

  247. 

  248.         stack = stackStart;

  249. 

  250.         for (i = 0; i &lt; radiusPlus1; i++) {

  251.             stack.r = pr;

  252.             stack.g = pg;

  253.             stack.b = pb;

  254.             stack.a = pa;

  255.             stack = stack.next;

  256.         }

  257. 

  258.         for (i = 1; i &lt; radiusPlus1; i++) {

  259.             p = yi + ((widthMinus1 &lt; i ? widthMinus1 : i) &lt;&lt; 2);

  260.             rSum += (stack.r = (pr = pixels[p])) * (rbs = radiusPlus1 - i);

  261.             gSum += (stack.g = (pg = pixels[p + 1])) * rbs;

  262.             bSum += (stack.b = (pb = pixels[p + 2])) * rbs;

  263.             aSum += (stack.a = (pa = pixels[p + 3])) * rbs;

  264. 

  265.             rInSum += pr;

  266.             gInSum += pg;

  267.             bInSum += pb;

  268.             aInSum += pa;

  269. 

  270.             stack = stack.next;

  271.         }

  272. 

  273.         stackIn = stackStart;

  274.         stackOut = stackEnd;

  275.         for (x = 0; x &lt; width; x++) {

  276.             pixels[yi + 3] = pa = (aSum * mulSum) >> shgSum;

  277.             if (pa !== 0) {

  278.                 pa = 255 / pa;

  279.                 pixels[yi] = ((rSum * mulSum) >> shgSum) * pa;

  280.                 pixels[yi + 1] = ((gSum * mulSum) >> shgSum) * pa;

  281.                 pixels[yi + 2] = ((bSum * mulSum) >> shgSum) * pa;

  282.             } else {

  283.                 pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;

  284.             }

  285. 

  286.             rSum -= rOutSum;

  287.             gSum -= gOutSum;

  288.             bSum -= bOutSum;

  289.             aSum -= aOutSum;

  290. 

  291.             rOutSum -= stackIn.r;

  292.             gOutSum -= stackIn.g;

  293.             bOutSum -= stackIn.b;

  294.             aOutSum -= stackIn.a;

  295. 

  296.             p = (yw + ((p = x + radius + 1) &lt; widthMinus1 ? p : widthMinus1)) &lt;&lt; 2;

  297. 

  298.             rInSum += (stackIn.r = pixels[p]);

  299.             gInSum += (stackIn.g = pixels[p + 1]);

  300.             bInSum += (stackIn.b = pixels[p + 2]);

  301.             aInSum += (stackIn.a = pixels[p + 3]);

  302. 

  303.             rSum += rInSum;

  304.             gSum += gInSum;

  305.             bSum += bInSum;

  306.             aSum += aInSum;

  307. 

  308.             stackIn = stackIn.next;

  309. 

  310.             rOutSum += (pr = stackOut.r);

  311.             gOutSum += (pg = stackOut.g);

  312.             bOutSum += (pb = stackOut.b);

  313.             aOutSum += (pa = stackOut.a);

  314. 

  315.             rInSum -= pr;

  316.             gInSum -= pg;

  317.             bInSum -= pb;

  318.             aInSum -= pa;

  319. 

  320.             stackOut = stackOut.next;

  321. 

  322.             yi += 4;

  323.         }

  324.         yw += width;

  325.     }

  326. 

  327.     for (x = 0; x &lt; width; x++) {

  328.         gInSum = bInSum = aInSum = rInSum = gSum = bSum = aSum = rSum = 0;

  329. 

  330.         yi = x &lt;&lt; 2;

  331.         rOutSum = radiusPlus1 * (pr = pixels[yi]);

  332.         gOutSum = radiusPlus1 * (pg = pixels[yi + 1]);

  333.         bOutSum = radiusPlus1 * (pb = pixels[yi + 2]);

  334.         aOutSum = radiusPlus1 * (pa = pixels[yi + 3]);

  335. 

  336.         rSum += sumFactor * pr;

  337.         gSum += sumFactor * pg;

  338.         bSum += sumFactor * pb;

  339.         aSum += sumFactor * pa;

  340. 

  341.         stack = stackStart;

  342. 

  343.         for (i = 0; i &lt; radiusPlus1; i++) {

  344.             stack.r = pr;

  345.             stack.g = pg;

  346.             stack.b = pb;

  347.             stack.a = pa;

  348.             stack = stack.next;

  349.         }

  350. 

  351.         yp = width;

  352. 

  353.         for (i = 1; i &lt;= radius; i++) {

  354.             yi = (yp + x) &lt;&lt; 2;

  355. 

  356.             rSum += (stack.r = (pr = pixels[yi])) * (rbs = radiusPlus1 - i);

  357.             gSum += (stack.g = (pg = pixels[yi + 1])) * rbs;

  358.             bSum += (stack.b = (pb = pixels[yi + 2])) * rbs;

  359.             aSum += (stack.a = (pa = pixels[yi + 3])) * rbs;

  360. 

  361.             rInSum += pr;

  362.             gInSum += pg;

  363.             bInSum += pb;

  364.             aInSum += pa;

  365. 

  366.             stack = stack.next;

  367. 

  368.             if (i &lt; heightMinus1) {

  369.                 yp += width;

  370.             }

  371.         }

  372. 

  373.         yi = x;

  374.         stackIn = stackStart;

  375.         stackOut = stackEnd;

  376.         for (y = 0; y &lt; height; y++) {

  377.             p = yi &lt;&lt; 2;

  378.             pixels[p + 3] = pa = (aSum * mulSum) >> shgSum;

  379.             if (pa > 0) {

  380.                 pa = 255 / pa;

  381.                 pixels[p] = ((rSum * mulSum) >> shgSum) * pa;

  382.                 pixels[p + 1] = ((gSum * mulSum) >> shgSum) * pa;

  383.                 pixels[p + 2] = ((bSum * mulSum) >> shgSum) * pa;

  384.             } else {

  385.                 pixels[p] = pixels[p + 1] = pixels[p + 2] = 0;

  386.             }

  387. 

  388.             rSum -= rOutSum;

  389.             gSum -= gOutSum;

  390.             bSum -= bOutSum;

  391.             aSum -= aOutSum;

  392. 

  393.             rOutSum -= stackIn.r;

  394.             gOutSum -= stackIn.g;

  395.             bOutSum -= stackIn.b;

  396.             aOutSum -= stackIn.a;

  397. 

  398.             p = (x + (((p = y + radiusPlus1) &lt; heightMinus1 ? p : heightMinus1) * width)) &lt;&lt; 2;

  399. 

  400.             rSum += (rInSum += (stackIn.r = pixels[p]));

  401.             gSum += (gInSum += (stackIn.g = pixels[p + 1]));

  402.             bSum += (bInSum += (stackIn.b = pixels[p + 2]));

  403.             aSum += (aInSum += (stackIn.a = pixels[p + 3]));

  404. 

  405.             stackIn = stackIn.next;

  406. 

  407.             rOutSum += (pr = stackOut.r);

  408.             gOutSum += (pg = stackOut.g);

  409.             bOutSum += (pb = stackOut.b);

  410.             aOutSum += (pa = stackOut.a);

  411. 

  412.             rInSum -= pr;

  413.             gInSum -= pg;

  414.             bInSum -= pb;

  415.             aInSum -= pa;

  416. 

  417.             stackOut = stackOut.next;

  418. 

  419.             yi += width;

  420.         }

  421.     }

  422.     return imageData;

  423. }

  424. 

  425. /**

  426.  * @param {HTMLCanvasElement} canvas

  427.  * @param {Integer} topX

  428.  * @param {Integer} topY

  429.  * @param {Integer} width

  430.  * @param {Integer} height

  431.  * @param {Float} radius

  432.  * @returns {undefined}

  433.  */

  434. function processCanvasRGB (canvas, topX, topY, width, height, radius) {

  435.     if (isNaN(radius) || radius &lt; 1) { return; }

  436.     radius |= 0;

  437. 

  438.     let imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);

  439.     imageData = processImageDataRGB(imageData, topX, topY, width, height, radius);

  440. 

  441.     canvas.getContext('2d').putImageData(imageData, topX, topY);

  442. }

  443. 

  444. /**

  445.  * @param {ImageData} imageData

  446.  * @param {Integer} topX

  447.  * @param {Integer} topY

  448.  * @param {Integer} width

  449.  * @param {Integer} height

  450.  * @param {Float} radius

  451.  * @returns {ImageData}

  452.  */

  453. function processImageDataRGB (imageData, topX, topY, width, height, radius) {

  454.     const pixels = imageData.data;

  455. 

  456.     let x, y, i, p, yp, yi, yw, rSum, gSum, bSum,

  457.         rOutSum, gOutSum, bOutSum,

  458.         rInSum, gInSum, bInSum,

  459.         pr, pg, pb, rbs;

  460. 

  461.     const div = 2 * radius + 1;

  462.     // const w4 = width &lt;&lt; 2;

  463.     const widthMinus1 = width - 1;

  464.     const heightMinus1 = height - 1;

  465.     const radiusPlus1 = radius + 1;

  466.     const sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;

  467. 

  468.     const stackStart = new BlurStack();

  469.     let stack = stackStart;

  470.     let stackEnd;

  471.     for (i = 1; i &lt; div; i++) {

  472.         stack = stack.next = new BlurStack();

  473.         if (i === radiusPlus1) {

  474.             stackEnd = stack;

  475.         }

  476.     }

  477.     stack.next = stackStart;

  478.     let stackIn = null;

  479.     let stackOut = null;

  480. 

  481.     yw = yi = 0;

  482. 

  483.     const mulSum = mulTable[radius];

  484.     const shgSum = shgTable[radius];

  485. 

  486.     for (y = 0; y &lt; height; y++) {

  487.         rInSum = gInSum = bInSum = rSum = gSum = bSum = 0;

  488. 

  489.         rOutSum = radiusPlus1 * (pr = pixels[yi]);

  490.         gOutSum = radiusPlus1 * (pg = pixels[yi + 1]);

  491.         bOutSum = radiusPlus1 * (pb = pixels[yi + 2]);

  492. 

  493.         rSum += sumFactor * pr;

  494.         gSum += sumFactor * pg;

  495.         bSum += sumFactor * pb;

  496. 

  497.         stack = stackStart;

  498. 

  499.         for (i = 0; i &lt; radiusPlus1; i++) {

  500.             stack.r = pr;

  501.             stack.g = pg;

  502.             stack.b = pb;

  503.             stack = stack.next;

  504.         }

  505. 

  506.         for (i = 1; i &lt; radiusPlus1; i++) {

  507.             p = yi + ((widthMinus1 &lt; i ? widthMinus1 : i) &lt;&lt; 2);

  508.             rSum += (stack.r = (pr = pixels[p])) * (rbs = radiusPlus1 - i);

  509.             gSum += (stack.g = (pg = pixels[p + 1])) * rbs;

  510.             bSum += (stack.b = (pb = pixels[p + 2])) * rbs;

  511. 

  512.             rInSum += pr;

  513.             gInSum += pg;

  514.             bInSum += pb;

  515. 

  516.             stack = stack.next;

  517.         }

  518. 

  519.         stackIn = stackStart;

  520.         stackOut = stackEnd;

  521.         for (x = 0; x &lt; width; x++) {

  522.             pixels[yi] = (rSum * mulSum) >> shgSum;

  523.             pixels[yi + 1] = (gSum * mulSum) >> shgSum;

  524.             pixels[yi + 2] = (bSum * mulSum) >> shgSum;

  525. 

  526.             rSum -= rOutSum;

  527.             gSum -= gOutSum;

  528.             bSum -= bOutSum;

  529. 

  530.             rOutSum -= stackIn.r;

  531.             gOutSum -= stackIn.g;

  532.             bOutSum -= stackIn.b;

  533. 

  534.             p = (yw + ((p = x + radius + 1) &lt; widthMinus1 ? p : widthMinus1)) &lt;&lt; 2;

  535. 

  536.             rInSum += (stackIn.r = pixels[p]);

  537.             gInSum += (stackIn.g = pixels[p + 1]);

  538.             bInSum += (stackIn.b = pixels[p + 2]);

  539. 

  540.             rSum += rInSum;

  541.             gSum += gInSum;

  542.             bSum += bInSum;

  543. 

  544.             stackIn = stackIn.next;

  545. 

  546.             rOutSum += (pr = stackOut.r);

  547.             gOutSum += (pg = stackOut.g);

  548.             bOutSum += (pb = stackOut.b);

  549. 

  550.             rInSum -= pr;

  551.             gInSum -= pg;

  552.             bInSum -= pb;

  553. 

  554.             stackOut = stackOut.next;

  555. 

  556.             yi += 4;

  557.         }

  558.         yw += width;

  559.     }

  560. 

  561.     for (x = 0; x &lt; width; x++) {

  562.         gInSum = bInSum = rInSum = gSum = bSum = rSum = 0;

  563. 

  564.         yi = x &lt;&lt; 2;

  565.         rOutSum = radiusPlus1 * (pr = pixels[yi]);

  566.         gOutSum = radiusPlus1 * (pg = pixels[yi + 1]);

  567.         bOutSum = radiusPlus1 * (pb = pixels[yi + 2]);

  568. 

  569.         rSum += sumFactor * pr;

  570.         gSum += sumFactor * pg;

  571.         bSum += sumFactor * pb;

  572. 

  573.         stack = stackStart;

  574. 

  575.         for (i = 0; i &lt; radiusPlus1; i++) {

  576.             stack.r = pr;

  577.             stack.g = pg;

  578.             stack.b = pb;

  579.             stack = stack.next;

  580.         }

  581. 

  582.         yp = width;

  583. 

  584.         for (i = 1; i &lt;= radius; i++) {

  585.             yi = (yp + x) &lt;&lt; 2;

  586. 

  587.             rSum += (stack.r = (pr = pixels[yi])) * (rbs = radiusPlus1 - i);

  588.             gSum += (stack.g = (pg = pixels[yi + 1])) * rbs;

  589.             bSum += (stack.b = (pb = pixels[yi + 2])) * rbs;

  590. 

  591.             rInSum += pr;

  592.             gInSum += pg;

  593.             bInSum += pb;

  594. 

  595.             stack = stack.next;

  596. 

  597.             if (i &lt; heightMinus1) {

  598.                 yp += width;

  599.             }

  600.         }

  601. 

  602.         yi = x;

  603.         stackIn = stackStart;

  604.         stackOut = stackEnd;

  605.         for (y = 0; y &lt; height; y++) {

  606.             p = yi &lt;&lt; 2;

  607.             pixels[p] = (rSum * mulSum) >> shgSum;

  608.             pixels[p + 1] = (gSum * mulSum) >> shgSum;

  609.             pixels[p + 2] = (bSum * mulSum) >> shgSum;

  610. 

  611.             rSum -= rOutSum;

  612.             gSum -= gOutSum;

  613.             bSum -= bOutSum;

  614. 

  615.             rOutSum -= stackIn.r;

  616.             gOutSum -= stackIn.g;

  617.             bOutSum -= stackIn.b;

  618. 

  619.             p = (x + (((p = y + radiusPlus1) &lt; heightMinus1 ? p : heightMinus1) * width)) &lt;&lt; 2;

  620. 

  621.             rSum += (rInSum += (stackIn.r = pixels[p]));

  622.             gSum += (gInSum += (stackIn.g = pixels[p + 1]));

  623.             bSum += (bInSum += (stackIn.b = pixels[p + 2]));

  624. 

  625.             stackIn = stackIn.next;

  626. 

  627.             rOutSum += (pr = stackOut.r);

  628.             gOutSum += (pg = stackOut.g);

  629.             bOutSum += (pb = stackOut.b);

  630. 

  631.             rInSum -= pr;

  632.             gInSum -= pg;

  633.             bInSum -= pb;

  634. 

  635.             stackOut = stackOut.next;

  636. 

  637.             yi += width;

  638.         }

  639.     }

  640. 

  641.     return imageData;

  642. }

  643. 

  644. /**

  645.  *

  646.  */

  647. export class BlurStack {

  648.     constructor () {

  649.         this.r = 0;

  650.         this.g = 0;

  651.         this.b = 0;

  652.         this.a = 0;

  653.         this.next = null;

  654.     }

  655. }

  656. 

  657. export {

  658.     /**

  659.     * @function module:StackBlur.image

  660.     * @see module:StackBlur~processImage

  661.     */

  662.     processImage as image,

  663.     /**

  664.     * @function module:StackBlur.canvasRGBA

  665.     * @see module:StackBlur~processCanvasRGBA

  666.     */

  667.     processCanvasRGBA as canvasRGBA,

  668.     /**

  669.     * @function module:StackBlur.canvasRGB

  670.     * @see module:StackBlur~processCanvasRGB

  671.     */

  672.     processCanvasRGB as canvasRGB,

  673.     /**

  674.     * @function module:StackBlur.imageDataRGBA

  675.     * @see module:StackBlur~processImageDataRGBA

  676.     */

  677.     processImageDataRGBA as imageDataRGBA,

  678.     /**

  679.     * @function module:StackBlur.imageDataRGB

  680.     * @see module:StackBlur~processImageDataRGB

  681.     */

  682.     processImageDataRGB as imageDataRGB

  683. };

  684. </code></pre>

  685.         </article>

  686.     </section>

  687. 

  688. 

  689. 

  690. 

  691. </div>

  692. 

  693. <nav>

  694.     <h2><a href="index.html">Home</a></h2><h3>Modules</h3><ul><li><a href="module-StackBlur.html">StackBlur</a></li></ul><h3>Classes</h3><ul><li><a href="module-StackBlur.BlurStack.html">BlurStack</a></li></ul>

  695. </nav>

  696. 

  697. <br class="clear">

  698. 

  699. <footer>

  700.     Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.5.5</a> on Thu Dec 13 2018 09:27:19 GMT+0800 (China Standard Time)

  701. </footer>

  702. 

  703. <script> prettyPrint(); </script>

  704. <script src="scripts/linenumber.js"> </script>

  705. </body>

  706. </html>