ace-colorpicker-rpk 0.0.12

package/src/util/Kmeans.js

@@ -0,0 +1,237 @@
+function array_equals(v1, v2) {
+    if (v1.length !== v2.length) return false;
+    for (var i = 0, len = v1.length; i < len; ++i) {
+        if (v1[i] !== v2[i]) return false;
+    }
+    return true;
+}
+
+function euclidean(v1, v2) {
+    var total = 0;
+
+    for (var i = 0, len = v1.length; i < len; i++) {
+        total += Math.pow(v2[i] - v1[i], 2);
+    }
+
+    return Math.sqrt(total);
+}
+
+function manhattan(v1, v2) {
+    var total = 0;
+
+    for (var i = 0, len = v1.length; i < len; i++) {
+        total += Math.abs(v2[i] - v1[i]);
+    }
+
+    return total;
+}
+
+function max(v1, v2) {
+    var max = 0;
+    for (var i = 0, len = v1.length; i < len; i++) {
+        max = Math.max(max, Math.abs(v2[i] - v1[i]));
+    }
+
+    return max;
+}
+
+
+
+const distances = {
+    euclidean,
+    manhattan,
+    max
+}
+
+const create_random_number = {
+    linear: function (num, count) {
+        var centeroids = [];
+        var start = Math.round(Math.random() * num);
+        var dist = Math.floor(num / count);
+
+        do {
+
+            centeroids.push(start);
+
+            start = (start + dist) % num;
+
+        } while (centeroids.length < count);
+
+
+        return centeroids;
+    },
+
+    shuffle: function (num, count) {
+        var centeroids = [];     
+
+        while (centeroids.length < count) {
+
+            var index = Math.round(Math.random() * num);
+
+            if (centeroids.indexOf(index) == -1) {
+                centeroids.push(index);
+            }
+
+        }
+
+        return centeroids;
+    }
+
+
+}
+
+function randomCentroids(points, k, method = 'linear') {
+
+    var centeroids = create_random_number[method](points.length, k);
+
+
+
+    return centeroids.map(i => {
+        return points[i];
+    })
+
+    // var centeroids = points.slice(0);
+
+    // centeroids.sort(function () {
+    //     return (Math.round(Math.random()) - 0.5);
+    // })
+
+    // return centeroids.slice(0, k); 
+}
+
+function closestCenteroid(point, centeroids, distance) {
+    var min = Infinity, kIndex = 0;
+
+    centeroids.forEach((center, i) => {
+        var dist = distance(point, center);
+
+        if (dist < min) {
+            min = dist;
+            kIndex = i;
+        }
+    })
+
+    return kIndex;
+}
+
+function getCenteroid(assigned) {
+
+    if (!assigned.length) return [];
+
+    // initialize centeroid list 
+    let centeroid = new Array(assigned[0].length);
+    for (var i = 0, len = centeroid.length; i < len; i++) {
+        centeroid[i] = 0;
+    }
+
+    for (var index = 0, len = assigned.length; index < len; index++) {
+        var it = assigned[index];
+
+        var last = (index + 1);
+
+        for (var j = 0, jLen = it.length; j < jLen; j++) {
+            centeroid[j] += (it[j] - centeroid[j]) / last;
+        }
+    }
+
+    centeroid = centeroid.map(it => {
+        return Math.floor(it);
+    })
+
+    return centeroid;
+}
+
+function unique_array(arrays) {
+    return arrays;
+    var set = {};
+    var count = arrays.length;
+    let it = null;
+    while (count--) {
+        it = arrays[count];
+        set[JSON.stringify(it)] = it;
+    }
+
+    return Object.values(set);
+}
+
+function splitK(k, points, centeroids, distance) {
+    let assignment = new Array(k);
+
+    for (var i = 0; i < k; i++) {
+        assignment[i] = [];
+    }
+
+    for (var idx = 0, pointLength = points.length; idx < pointLength; idx++) {
+        var point = points[idx];
+        var index = closestCenteroid(point, centeroids, distance);
+        assignment[index].push(point);
+    }
+
+    return assignment;
+}
+
+function setNewCenteroid(k, points, assignment, centeroids, movement, randomFunction) {
+
+
+    for (var i = 0; i < k; i++) {
+        let assigned = assignment[i];
+
+        const centeroid = centeroids[i];
+        let newCenteroid = new Array(centeroid.length);
+
+        if (assigned.length > 0) {
+            newCenteroid = getCenteroid(assigned);
+        } else {
+            var idx = Math.floor(randomFunction() * points.length);
+            newCenteroid = points[idx];
+        }
+
+        if (array_equals(newCenteroid, centeroid)) {
+            movement = false;
+        } else {
+            movement = true;
+        }
+
+        centeroids[i] = newCenteroid;
+    }
+
+    return movement;
+}
+
+function kmeans(points, k, distanceFunction, period = 10, initialRandom = 'linear') {
+    points = unique_array(points);
+
+    k = k || Math.max(2, Math.ceil(Math.sqrt(points.length / 2)));
+
+    let distance = distanceFunction || 'euclidean';
+    if (typeof distance == 'string') {
+        distance = distances[distance];
+    }
+
+    var rng_seed = 0;
+    var random = function () {
+        rng_seed = (rng_seed * 9301 + 49297) % 233280;
+        return rng_seed / 233280;
+    };
+
+    let centeroids = randomCentroids(points, k, initialRandom);
+
+    let movement = true;
+    let iterations = 0;
+    while (movement) {
+        const assignment = splitK(k, points, centeroids, distance);
+
+        movement = setNewCenteroid(k, points, assignment, centeroids, false, random);
+
+        iterations++;
+
+        if (iterations % period == 0) {
+            break;
+        }
+
+    }
+
+    return centeroids;
+}
+
+export default kmeans

package/src/util/Matrix.js

@@ -0,0 +1,196 @@
+const CONSTANT = {
+
+    identity () {
+        return [
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1 
+        ]
+    },
+
+    stretching (k) {
+        return [
+            k, 0, 0,
+            0, 1, 0,
+            0, 0, 1
+        ]
+    },
+
+    squeezing (k) {
+        return [
+            k, 0, 0,
+            0, 1/k, 0,
+            0, 0, 1
+        ]
+    },
+
+    scale (sx = 1, sy = 1) {
+        sx = sx || sx === 0 ? sx : 1;
+        sy = sy || sy === 0 ? sy : 1;
+        return [
+            sx, 0, 0,
+            0, sy, 0,
+            0, 0, 1
+        ]
+    },
+
+    scaleX (sx) {
+        return this.scale(sx)
+    },
+
+    scaleY (sy) {
+        return this.scale(1, sy)
+    },    
+
+    translate (tx, ty) {
+        return [
+            1, 0, tx,
+            0, 1, ty,
+            0, 0, 1
+        ]
+    },
+
+    rotate (angle){
+        const r = this.radian(angle)
+        return [
+            Math.cos(r), -Math.sin(r), 0,
+            Math.sin(r), Math.cos(r), 0,
+            0, 0, 1
+        ]
+    },
+
+    rotate90 () {
+        return [
+            0, -1, 0,
+            1, 0, 0,
+            0, 0, 1
+        ]
+    },
+
+    rotate180 () {
+        return [
+            -1, 0, 0,
+            0, -1, 0,
+            0, 0, 1
+        ]
+    },    
+
+    rotate270 () {
+        return [
+            0, 1, 0,
+            -1, 0, 0,
+            0, 0, 1
+        ]
+    },        
+
+    radian (degree) {
+        return degree * Math.PI / 180
+    },
+
+    skew (degreeX, degreeY) { 
+        const radianX = this.radian(degreeX);
+        const radianY = this.radian(degreeY);
+        return [
+            1, Math.tan(radianX), 0, 
+            Math.tan(radianY), 1, 0,
+            0, 0, 1 
+        ]
+    },
+
+    skewX (degreeX) {
+        const radianX = this.radian(degreeX);
+        
+        return [
+            1, Math.tan(radianX), 0, 
+            0, 1, 0,
+            0, 0, 1 
+        ]
+    },
+
+    skewY (degreeY) {
+        const radianY = this.radian(degreeY);
+        
+        return [
+            1, 0, 0, 
+            Math.tan(radianY), 1, 0,
+            0, 0, 1 
+        ]
+    },    
+
+    shear1 (angle) {
+        return [
+            1, -Math.tan(this.radian(angle)/2), 0,
+            0, 1, 0,
+            0, 0, 1
+        ]
+    }, 
+    shear2 (angle) {
+        return [
+            1, 0, 0,
+            Math.sin(this.radian(angle)), 1, 0,
+            0, 0, 1
+        ]
+    }
+}
+
+const Matrix = {
+    CONSTANT,
+
+    radian (angle) {
+        return CONSTANT.radian(angle)
+    },
+
+    multiply (A, C) {        
+        // console.log(JSON.stringify(A), JSON.stringify(C))
+        return [   
+            A[0] * C[0] + A[1] * C[1] + A[2] * C[2], 
+            A[3] * C[0] + A[4] * C[1] + A[5] * C[2],
+            A[6] * C[0] + A[7] * C[1] + A[8] * C[2]
+        ]
+    },
+
+    identity (B) {
+        return this.multiply(CONSTANT.identity(), B)
+    },
+
+    translate (x, y, B) {
+        return this.multiply(
+            CONSTANT.translate(x, y),
+            B
+        )
+    },
+
+    rotate (angle, B) {
+        return this.multiply(
+            CONSTANT.rotate(angle),
+            B
+        )
+    },
+
+    shear1 (angle, B) {
+        return this.multiply(
+            CONSTANT.shear1(angle),
+            B
+        )
+    },
+
+    shear2 (angle, B) {
+        return this.multiply(
+            CONSTANT.shear2(angle),
+            B
+        )
+    },    
+
+    rotateShear(angle, B) {
+
+        let arr = B 
+
+        arr = this.shear1(angle, arr)
+        arr = this.shear2(angle, arr)
+        arr = this.shear1(angle, arr)
+
+        return arr
+    }
+}
+
+export default Matrix 

package/src/util/State.js

@@ -0,0 +1,42 @@
+const DELEGATE_SPLIT = '.';
+
+export default class State {
+  constructor (masterObj, settingObj = {}) {
+
+    this.masterObj = masterObj;
+    this.settingObj = settingObj; 
+  }
+
+  set (key, value, defaultValue = undefined) {
+    this.settingObj[key] = value || defaultValue;
+  }
+
+  init (key, ...args) {
+
+    if (!this.has(key)) {
+
+      const arr = key.split(DELEGATE_SPLIT);
+
+      const obj = this.masterObj.refs[arr[0]] || this.masterObj[arr[0]] || this.masterObj;
+      const method = arr.pop();
+
+      if (obj[method]) {
+        const value = obj[method].apply(obj, args);
+
+        this.set(key, value);
+      }
+
+    }
+  }
+
+  get (key, defaultValue = '') {
+
+    this.init(key, defaultValue);
+
+    return this.settingObj[key] || defaultValue;
+  }
+
+  has (key) {
+    return !!this.settingObj[key];
+  }
+}

package/src/util/blend/composite.js

@@ -0,0 +1,124 @@
+const modes = {
+  'clear' : {
+    alpha () { return 0; },
+    color () { return 0; } 
+  },
+  'copy' : {
+    alpha (Ab, As) {
+      return As;
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs;
+    }
+  },
+  'destination' : {
+    alpha (Ab, As) {
+      return Ab;
+    },
+    color (Ab, As, Cb, Cs) {
+      return Ab * Cb;
+    }
+  },
+  'source-over' : {
+    alpha (Ab, As) {
+      return As + Ab * ( 1 - As);
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs + Ab * Cb * (1 - As);
+    }
+  },
+  'destination-over' : {
+    alpha (Ab, As) {
+      return As * (1 - Ab) + Ab;
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs * (1 - Ab) + Ab * Cb;
+    }
+  },
+  'source-in' : {
+    alpha (Ab, As) {
+      return As * Ab;
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs * Ab;
+    }
+  },
+  'destination-in' : {
+    alpha (Ab, As) {
+      return As * Ab;
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cb * Ab;
+    }
+  },
+  'source-out' : {
+    alpha (Ab, As) {
+      return As * (1 - Ab);
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs * (1 - Ab);
+    }
+  },
+  'destination-out' : {
+    alpha (Ab, As) {
+      return Ab * (1 - As);
+    },
+    color (Ab, As, Cb, Cs) {
+      return Ab * Cb * (1 - As);
+    }
+  },
+  'source-atop' : {
+    alpha (Ab, As) {
+      return As * Ab + Ab * (1 - As);
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs * Ab + Ab * Cb * (1 - As);
+    }
+  },
+  'destination-atop' : {
+    alpha (Ab, As) {
+      return As * (1 - Ab) + Ab * As;
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs * (1 - Ab) + Ab * Cb * As;
+    }
+  },
+  'xor' : {
+    alpha (Ab, As) {
+      return As * (1 - Ab) + Ab * (1 - As);
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs * (1 - Ab) + Ab * Cb * (1 - As);
+    }
+  },
+  'lighter' : {
+    alpha (Ab, As) {
+      return As + Ab
+    },
+    color (Ab, As, Cb, Cs) {
+      return As * Cs + Ab * Cb;
+    }
+  }
+
+  
+
+
+}
+
+function composite (back, source, mode) {
+  return {
+    r : modes[mode].color(back.a, source.a, back.r / 255, source.r / 255) * 255,
+    g : modes[mode].color(back.a, source.a, back.g / 255, source.g / 255) * 255,
+    b : modes[mode].color(back.a, source.a, back.b / 255, source.b / 255) * 255,
+    a : modes[mode].alpha(back.a, source.a)
+  }
+}
+
+// alias 
+Object.keys(modes).forEach(mode => {
+  composite[mode] = function (back, source) {
+    return composite(back, source, mode);
+  }
+})
+
+export default composite;

package/src/util/blend/non-separable.js

@@ -0,0 +1,118 @@
+// refer to https://www.w3.org/TR/compositing-1
+
+var util = {
+  lum ( color) {
+    return 0.3 * color.r  + 0.59 * color.g + 0.11 * color.b;
+  },
+
+  clipColor(c) {
+    const l = this.lum(c)
+    const n = this.min(c)
+    const x = this.max(c)
+
+    let color = Object.assign({}, c);
+
+    if(n < 0) {
+      color.r = l + (((color.r - l) * l) / (l - n))
+      color.g = l + (((color.g - l) * l) / (l - n))
+      color.b = l + (((color.b - l) * l) / (l - n))
+    }
+        
+                  
+    if(x > 1) {
+      color.r = l + (((color.r - l) * (1 - l)) / (x - l))
+      color.g = l + (((color.g - l) * (1 - l)) / (x - l))
+      color.b = l + (((color.b - l) * (1 - l)) / (x - l))
+    }
+    
+    return color;
+  },
+  setLum(color, l) {
+    const d = l - this.lum(color)
+    const r = color.r + d; 
+    const g = color.g + d; 
+    const b = color.b + d; 
+        
+    return this.clipColor({r, g, b})
+  },
+
+  sat (color) {
+    return  this.max(color) - this.min(color)
+  },
+
+  max (color) {
+    return Math.max(color.r, color.g, color.b);
+  },
+
+  min (color) {
+    return Math.min(color.r, color.g, color.b);
+  },
+
+  mid (color) {
+    return (color.r + color.g + color.b) - this.max(color) - this.min(color);
+  },  
+
+  setSat(color, s) {
+    color.max = this.max(color);
+    color.min = this.min(color);
+    color.mid = this.mid(color);
+
+    if(color.max > color.min) {
+      color.mid = (((color.mid - color.min) * s) / (color.max - color.min))
+      color.max = s
+    } else {
+      color.mid = color.max =  0
+    }
+      
+    color.min = 0
+
+    return color;
+  }
+}
+
+var modes = {
+  /* nonseparable mode */ 
+  hue (back, source) {
+    return util.setLum(util.setSat(source, util.sat(back)), util.lum(back))
+  },
+
+  saturation (back, source) {
+    return util.setLum(util.setSat(back, util.sat(source)), util.lum(back))
+  },
+  
+  color (back, source) {
+    return util.setLum(source, util.lum(back));
+  },
+
+  luminosity (back, source) {
+    return util.setLum(back, util.lum(source))
+  }
+
+}
+
+function recover (c) {
+  c.r *= 255; 
+  c.g *= 255; 
+  c.b *= 255; 
+  return c;
+}
+
+function minify (c) {
+  c.r /= 255;
+  c.g /= 255;
+  c.b /= 255;
+  return c;
+}
+
+function nonseparable (back, source, mode) {
+  return recover(modes[mode](minify(back), minify(source)));
+}
+
+// alias 
+Object.keys(modes).forEach(mode => {
+  nonseparable[mode] = function (back, source) {
+    return nonseparable(back, source, mode);
+  }
+})
+
+export default nonseparable;