@nasser-sw/fabric 7.0.1-beta8 → 7.0.1-beta9

package/debug/konva-master/src/filters/Blur.ts

@@ -0,0 +1,388 @@
+import { Factory } from '../Factory.ts';
+import type { Filter } from '../Node.ts';
+import { Node } from '../Node.ts';
+import { getNumberValidator } from '../Validators.ts';
+/*
+ the Gauss filter
+ master repo: https://github.com/pavelpower/kineticjsGaussFilter
+*/
+/*
+
+     StackBlur - a fast almost Gaussian Blur For Canvas
+
+     Version:   0.5
+     Author:    Mario Klingemann
+     Contact:   mario@quasimondo.com
+     Website:   http://www.quasimondo.com/StackBlurForCanvas
+     Twitter:   @quasimondo
+
+     In case you find this class useful - especially in commercial projects -
+     I am not totally unhappy for a small donation to my PayPal account
+     mario@quasimondo.de
+
+     Or support me on flattr:
+     https://flattr.com/thing/72791/StackBlur-a-fast-almost-Gaussian-Blur-Effect-for-CanvasJavascript
+
+     Copyright (c) 2010 Mario Klingemann
+
+     Permission is hereby granted, free of charge, to any person
+     obtaining a copy of this software and associated documentation
+     files (the "Software"), to deal in the Software without
+     restriction, including without limitation the rights to use,
+     copy, modify, merge, publish, distribute, sublicense, and/or sell
+     copies of the Software, and to permit persons to whom the
+     Software is furnished to do so, subject to the following
+     conditions:
+
+     The above copyright notice and this permission notice shall be
+     included in all copies or substantial portions of the Software.
+
+     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+     OTHER DEALINGS IN THE SOFTWARE.
+     * @license MIT
+     */
+
+function BlurStack(this: any) {
+  this.r = 0;
+  this.g = 0;
+  this.b = 0;
+  this.a = 0;
+  this.next = null;
+}
+
+const mul_table = [
+  512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292,
+  512, 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292,
+  273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259,
+  496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292,
+  282, 273, 265, 512, 497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373,
+  364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271, 265, 259,
+  507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381,
+  374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312, 307, 302, 297, 292,
+  287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482, 475, 468, 461,
+  454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373,
+  368, 364, 359, 354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309,
+  305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271, 268, 265, 262, 259,
+  257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442,
+  437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381,
+  377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335, 332,
+  329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292,
+  289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259,
+];
+
+const shg_table = [
+  9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17,
+  17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19,
+  19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+  20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22,
+  22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+  22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23,
+  23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+  23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+  23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+  24, 24, 24, 24, 24, 24, 24,
+];
+
+function filterGaussBlurRGBA(imageData, radius) {
+  const pixels = imageData.data,
+    width = imageData.width,
+    height = imageData.height;
+
+  let p,
+    yi,
+    yw,
+    r_sum,
+    g_sum,
+    b_sum,
+    a_sum,
+    r_out_sum,
+    g_out_sum,
+    b_out_sum,
+    a_out_sum,
+    r_in_sum,
+    g_in_sum,
+    b_in_sum,
+    a_in_sum,
+    pr,
+    pg,
+    pb,
+    pa,
+    rbs;
+
+  const div = radius + radius + 1,
+    widthMinus1 = width - 1,
+    heightMinus1 = height - 1,
+    radiusPlus1 = radius + 1,
+    sumFactor = (radiusPlus1 * (radiusPlus1 + 1)) / 2,
+    stackStart = new BlurStack(),
+    mul_sum = mul_table[radius],
+    shg_sum = shg_table[radius];
+
+  let stackEnd = null,
+    stack = stackStart,
+    stackIn: any = null,
+    stackOut: any = null;
+
+  for (let i = 1; i < div; i++) {
+    stack = stack.next = new BlurStack();
+    if (i === radiusPlus1) {
+      stackEnd = stack;
+    }
+  }
+
+  stack.next = stackStart;
+
+  yw = yi = 0;
+
+  for (let y = 0; y < height; y++) {
+    r_in_sum =
+      g_in_sum =
+      b_in_sum =
+      a_in_sum =
+      r_sum =
+      g_sum =
+      b_sum =
+      a_sum =
+        0;
+
+    r_out_sum = radiusPlus1 * (pr = pixels[yi]);
+    g_out_sum = radiusPlus1 * (pg = pixels[yi + 1]);
+    b_out_sum = radiusPlus1 * (pb = pixels[yi + 2]);
+    a_out_sum = radiusPlus1 * (pa = pixels[yi + 3]);
+
+    r_sum += sumFactor * pr;
+    g_sum += sumFactor * pg;
+    b_sum += sumFactor * pb;
+    a_sum += sumFactor * pa;
+
+    stack = stackStart;
+
+    for (let i = 0; i < radiusPlus1; i++) {
+      stack.r = pr;
+      stack.g = pg;
+      stack.b = pb;
+      stack.a = pa;
+      stack = stack.next;
+    }
+
+    for (let i = 1; i < radiusPlus1; i++) {
+      p = yi + ((widthMinus1 < i ? widthMinus1 : i) << 2);
+      r_sum += (stack.r = pr = pixels[p]) * (rbs = radiusPlus1 - i);
+      g_sum += (stack.g = pg = pixels[p + 1]) * rbs;
+      b_sum += (stack.b = pb = pixels[p + 2]) * rbs;
+      a_sum += (stack.a = pa = pixels[p + 3]) * rbs;
+
+      r_in_sum += pr;
+      g_in_sum += pg;
+      b_in_sum += pb;
+      a_in_sum += pa;
+
+      stack = stack.next;
+    }
+
+    stackIn = stackStart;
+    stackOut = stackEnd;
+    for (let x = 0; x < width; x++) {
+      pixels[yi + 3] = pa = (a_sum * mul_sum) >> shg_sum;
+      if (pa !== 0) {
+        pa = 255 / pa;
+        pixels[yi] = ((r_sum * mul_sum) >> shg_sum) * pa;
+        pixels[yi + 1] = ((g_sum * mul_sum) >> shg_sum) * pa;
+        pixels[yi + 2] = ((b_sum * mul_sum) >> shg_sum) * pa;
+      } else {
+        pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;
+      }
+
+      r_sum -= r_out_sum;
+      g_sum -= g_out_sum;
+      b_sum -= b_out_sum;
+      a_sum -= a_out_sum;
+
+      r_out_sum -= stackIn.r;
+      g_out_sum -= stackIn.g;
+      b_out_sum -= stackIn.b;
+      a_out_sum -= stackIn.a;
+
+      p = (yw + ((p = x + radius + 1) < widthMinus1 ? p : widthMinus1)) << 2;
+
+      r_in_sum += stackIn.r = pixels[p];
+      g_in_sum += stackIn.g = pixels[p + 1];
+      b_in_sum += stackIn.b = pixels[p + 2];
+      a_in_sum += stackIn.a = pixels[p + 3];
+
+      r_sum += r_in_sum;
+      g_sum += g_in_sum;
+      b_sum += b_in_sum;
+      a_sum += a_in_sum;
+
+      stackIn = stackIn.next;
+
+      r_out_sum += pr = stackOut.r;
+      g_out_sum += pg = stackOut.g;
+      b_out_sum += pb = stackOut.b;
+      a_out_sum += pa = stackOut.a;
+
+      r_in_sum -= pr;
+      g_in_sum -= pg;
+      b_in_sum -= pb;
+      a_in_sum -= pa;
+
+      stackOut = stackOut.next;
+
+      yi += 4;
+    }
+    yw += width;
+  }
+
+  for (let x = 0; x < width; x++) {
+    g_in_sum =
+      b_in_sum =
+      a_in_sum =
+      r_in_sum =
+      g_sum =
+      b_sum =
+      a_sum =
+      r_sum =
+        0;
+
+    yi = x << 2;
+    r_out_sum = radiusPlus1 * (pr = pixels[yi]);
+    g_out_sum = radiusPlus1 * (pg = pixels[yi + 1]);
+    b_out_sum = radiusPlus1 * (pb = pixels[yi + 2]);
+    a_out_sum = radiusPlus1 * (pa = pixels[yi + 3]);
+
+    r_sum += sumFactor * pr;
+    g_sum += sumFactor * pg;
+    b_sum += sumFactor * pb;
+    a_sum += sumFactor * pa;
+
+    stack = stackStart;
+
+    for (let i = 0; i < radiusPlus1; i++) {
+      stack.r = pr;
+      stack.g = pg;
+      stack.b = pb;
+      stack.a = pa;
+      stack = stack.next;
+    }
+
+    let yp = width;
+
+    for (let i = 1; i <= radius; i++) {
+      yi = (yp + x) << 2;
+
+      r_sum += (stack.r = pr = pixels[yi]) * (rbs = radiusPlus1 - i);
+      g_sum += (stack.g = pg = pixels[yi + 1]) * rbs;
+      b_sum += (stack.b = pb = pixels[yi + 2]) * rbs;
+      a_sum += (stack.a = pa = pixels[yi + 3]) * rbs;
+
+      r_in_sum += pr;
+      g_in_sum += pg;
+      b_in_sum += pb;
+      a_in_sum += pa;
+
+      stack = stack.next;
+
+      if (i < heightMinus1) {
+        yp += width;
+      }
+    }
+
+    yi = x;
+    stackIn = stackStart;
+    stackOut = stackEnd;
+    for (let y = 0; y < height; y++) {
+      p = yi << 2;
+      pixels[p + 3] = pa = (a_sum * mul_sum) >> shg_sum;
+      if (pa > 0) {
+        pa = 255 / pa;
+        pixels[p] = ((r_sum * mul_sum) >> shg_sum) * pa;
+        pixels[p + 1] = ((g_sum * mul_sum) >> shg_sum) * pa;
+        pixels[p + 2] = ((b_sum * mul_sum) >> shg_sum) * pa;
+      } else {
+        pixels[p] = pixels[p + 1] = pixels[p + 2] = 0;
+      }
+
+      r_sum -= r_out_sum;
+      g_sum -= g_out_sum;
+      b_sum -= b_out_sum;
+      a_sum -= a_out_sum;
+
+      r_out_sum -= stackIn.r;
+      g_out_sum -= stackIn.g;
+      b_out_sum -= stackIn.b;
+      a_out_sum -= stackIn.a;
+
+      p =
+        (x +
+          ((p = y + radiusPlus1) < heightMinus1 ? p : heightMinus1) * width) <<
+        2;
+
+      r_sum += r_in_sum += stackIn.r = pixels[p];
+      g_sum += g_in_sum += stackIn.g = pixels[p + 1];
+      b_sum += b_in_sum += stackIn.b = pixels[p + 2];
+      a_sum += a_in_sum += stackIn.a = pixels[p + 3];
+
+      stackIn = stackIn.next;
+
+      r_out_sum += pr = stackOut.r;
+      g_out_sum += pg = stackOut.g;
+      b_out_sum += pb = stackOut.b;
+      a_out_sum += pa = stackOut.a;
+
+      r_in_sum -= pr;
+      g_in_sum -= pg;
+      b_in_sum -= pb;
+      a_in_sum -= pa;
+
+      stackOut = stackOut.next;
+
+      yi += width;
+    }
+  }
+}
+
+/**
+ * Blur Filter
+ * @function
+ * @name Blur
+ * @memberof Konva.Filters
+ * @param {Object} imageData
+ * @example
+ * node.cache();
+ * node.filters([Konva.Filters.Blur]);
+ * node.blurRadius(10);
+ */
+export const Blur: Filter = function Blur(imageData) {
+  const radius = Math.round(this.blurRadius());
+
+  if (radius > 0) {
+    filterGaussBlurRGBA(imageData, radius);
+  }
+};
+
+Factory.addGetterSetter(
+  Node,
+  'blurRadius',
+  0,
+  getNumberValidator(),
+  Factory.afterSetFilter
+);
+
+/**
+ * get/set blur radius. Use with {@link Konva.Filters.Blur} filter
+ * @name Konva.Node#blurRadius
+ * @method
+ * @param {Integer} radius
+ * @returns {Integer}
+ */

package/debug/konva-master/src/filters/Brighten.ts

@@ -0,0 +1,48 @@
+import { Factory } from '../Factory.ts';
+import type { Filter } from '../Node.ts';
+import { Node } from '../Node.ts';
+import { getNumberValidator } from '../Validators.ts';
+
+/**
+ * Brighten Filter.
+ * @deprecated Use {@link Konva.Filters.Brightness} instead for CSS-compatible behavior.
+ * This filter uses additive brightness adjustment (adds a constant value to RGB channels).
+ * @function
+ * @memberof Konva.Filters
+ * @param {Object} imageData
+ * @example
+ * node.cache();
+ * node.filters([Konva.Filters.Brighten]);
+ * node.brightness(0.8);
+ */
+export const Brighten: Filter = function (imageData) {
+  const brightness = this.brightness() * 255,
+    data = imageData.data,
+    len = data.length;
+
+  for (let i = 0; i < len; i += 4) {
+    // red
+    data[i] += brightness;
+    // green
+    data[i + 1] += brightness;
+    // blue
+    data[i + 2] += brightness;
+  }
+};
+
+Factory.addGetterSetter(
+  Node,
+  'brightness',
+  0,
+  getNumberValidator(),
+  Factory.afterSetFilter
+);
+/**
+ * get/set filter brightness.  The brightness is a number between -1 and 1.&nbsp; Positive values
+ *  brighten the pixels and negative values darken them. Use with {@link Konva.Filters.Brighten} filter.
+ * @name Konva.Node#brightness
+ * @method
+
+ * @param {Number} brightness value between -1 and 1
+ * @returns {Number}
+ */

package/debug/konva-master/src/filters/Brightness.ts

@@ -0,0 +1,30 @@
+import type { Filter } from '../Node.ts';
+
+/**
+ * Brightness Filter.
+ * CSS-compatible brightness filter that uses multiplicative approach.
+ * @function
+ * @memberof Konva.Filters
+ * @param {Object} imageData
+ * @example
+ * node.cache();
+ * node.filters([Konva.Filters.Brightness]);
+ * node.brightness(1.5); // 50% brighter (CSS-compatible)
+ */
+export const Brightness: Filter = function (imageData) {
+  const brightness = this.brightness(),
+    data = imageData.data,
+    len = data.length;
+
+  for (let i = 0; i < len; i += 4) {
+    // red
+    data[i] = Math.min(255, data[i] * brightness);
+    // green
+    data[i + 1] = Math.min(255, data[i + 1] * brightness);
+    // blue
+    data[i + 2] = Math.min(255, data[i + 2] * brightness);
+  }
+};
+
+// Note: brightness property is already defined in Brighten.ts
+// This filter reuses the existing brightness property but with CSS-compatible behavior

package/debug/konva-master/src/filters/Contrast.ts

@@ -0,0 +1,75 @@
+import { Factory } from '../Factory.ts';
+import type { Filter } from '../Node.ts';
+import { Node } from '../Node.ts';
+import { getNumberValidator } from '../Validators.ts';
+/**
+ * Contrast Filter.
+ * @function
+ * @memberof Konva.Filters
+ * @param {Object} imageData
+ * @example
+ * node.cache();
+ * node.filters([Konva.Filters.Contrast]);
+ * node.contrast(10);
+ */
+
+export const Contrast: Filter = function (imageData) {
+  const adjust = Math.pow((this.contrast() + 100) / 100, 2);
+
+  const data = imageData.data,
+    nPixels = data.length;
+  let red = 150,
+    green = 150,
+    blue = 150;
+
+  for (let i = 0; i < nPixels; i += 4) {
+    red = data[i];
+    green = data[i + 1];
+    blue = data[i + 2];
+
+    //Red channel
+    red /= 255;
+    red -= 0.5;
+    red *= adjust;
+    red += 0.5;
+    red *= 255;
+
+    //Green channel
+    green /= 255;
+    green -= 0.5;
+    green *= adjust;
+    green += 0.5;
+    green *= 255;
+
+    //Blue channel
+    blue /= 255;
+    blue -= 0.5;
+    blue *= adjust;
+    blue += 0.5;
+    blue *= 255;
+
+    red = red < 0 ? 0 : red > 255 ? 255 : red;
+    green = green < 0 ? 0 : green > 255 ? 255 : green;
+    blue = blue < 0 ? 0 : blue > 255 ? 255 : blue;
+
+    data[i] = red;
+    data[i + 1] = green;
+    data[i + 2] = blue;
+  }
+};
+
+/**
+ * get/set filter contrast.  The contrast is a number between -100 and 100.
+ * Use with {@link Konva.Filters.Contrast} filter.
+ * @name Konva.Node#contrast
+ * @method
+ * @param {Number} contrast value between -100 and 100
+ * @returns {Number}
+ */
+Factory.addGetterSetter(
+  Node,
+  'contrast',
+  0,
+  getNumberValidator(),
+  Factory.afterSetFilter
+);