simview 3.2__py3-none-any.whl

simview/static/lib/chroma-js-3.1.2/src/utils/analyze.js

@@ -0,0 +1,191 @@
+import type from './type.js';
+
+const { log, pow, floor, abs } = Math;
+
+export function analyze(data, key = null) {
+    const r = {
+        min: Number.MAX_VALUE,
+        max: Number.MAX_VALUE * -1,
+        sum: 0,
+        values: [],
+        count: 0
+    };
+    if (type(data) === 'object') {
+        data = Object.values(data);
+    }
+    data.forEach((val) => {
+        if (key && type(val) === 'object') val = val[key];
+        if (val !== undefined && val !== null && !isNaN(val)) {
+            r.values.push(val);
+            r.sum += val;
+            if (val < r.min) r.min = val;
+            if (val > r.max) r.max = val;
+            r.count += 1;
+        }
+    });
+
+    r.domain = [r.min, r.max];
+
+    r.limits = (mode, num) => limits(r, mode, num);
+
+    return r;
+}
+
+export function limits(data, mode = 'equal', num = 7) {
+    if (type(data) == 'array') {
+        data = analyze(data);
+    }
+    const { min, max } = data;
+    const values = data.values.sort((a, b) => a - b);
+
+    if (num === 1) {
+        return [min, max];
+    }
+
+    const limits = [];
+
+    if (mode.substr(0, 1) === 'c') {
+        // continuous
+        limits.push(min);
+        limits.push(max);
+    }
+
+    if (mode.substr(0, 1) === 'e') {
+        // equal interval
+        limits.push(min);
+        for (let i = 1; i < num; i++) {
+            limits.push(min + (i / num) * (max - min));
+        }
+        limits.push(max);
+    } else if (mode.substr(0, 1) === 'l') {
+        // log scale
+        if (min <= 0) {
+            throw new Error(
+                'Logarithmic scales are only possible for values > 0'
+            );
+        }
+        const min_log = Math.LOG10E * log(min);
+        const max_log = Math.LOG10E * log(max);
+        limits.push(min);
+        for (let i = 1; i < num; i++) {
+            limits.push(pow(10, min_log + (i / num) * (max_log - min_log)));
+        }
+        limits.push(max);
+    } else if (mode.substr(0, 1) === 'q') {
+        // quantile scale
+        limits.push(min);
+        for (let i = 1; i < num; i++) {
+            const p = ((values.length - 1) * i) / num;
+            const pb = floor(p);
+            if (pb === p) {
+                limits.push(values[pb]);
+            } else {
+                // p > pb
+                const pr = p - pb;
+                limits.push(values[pb] * (1 - pr) + values[pb + 1] * pr);
+            }
+        }
+        limits.push(max);
+    } else if (mode.substr(0, 1) === 'k') {
+        // k-means clustering
+        /*
+        implementation based on
+        http://code.google.com/p/figue/source/browse/trunk/figue.js#336
+        simplified for 1-d input values
+        */
+        let cluster;
+        const n = values.length;
+        const assignments = new Array(n);
+        const clusterSizes = new Array(num);
+        let repeat = true;
+        let nb_iters = 0;
+        let centroids = null;
+
+        // get seed values
+        centroids = [];
+        centroids.push(min);
+        for (let i = 1; i < num; i++) {
+            centroids.push(min + (i / num) * (max - min));
+        }
+        centroids.push(max);
+
+        while (repeat) {
+            // assignment step
+            for (let j = 0; j < num; j++) {
+                clusterSizes[j] = 0;
+            }
+            for (let i = 0; i < n; i++) {
+                const value = values[i];
+                let mindist = Number.MAX_VALUE;
+                let best;
+                for (let j = 0; j < num; j++) {
+                    const dist = abs(centroids[j] - value);
+                    if (dist < mindist) {
+                        mindist = dist;
+                        best = j;
+                    }
+                    clusterSizes[best]++;
+                    assignments[i] = best;
+                }
+            }
+
+            // update centroids step
+            const newCentroids = new Array(num);
+            for (let j = 0; j < num; j++) {
+                newCentroids[j] = null;
+            }
+            for (let i = 0; i < n; i++) {
+                cluster = assignments[i];
+                if (newCentroids[cluster] === null) {
+                    newCentroids[cluster] = values[i];
+                } else {
+                    newCentroids[cluster] += values[i];
+                }
+            }
+            for (let j = 0; j < num; j++) {
+                newCentroids[j] *= 1 / clusterSizes[j];
+            }
+
+            // check convergence
+            repeat = false;
+            for (let j = 0; j < num; j++) {
+                if (newCentroids[j] !== centroids[j]) {
+                    repeat = true;
+                    break;
+                }
+            }
+
+            centroids = newCentroids;
+            nb_iters++;
+
+            if (nb_iters > 200) {
+                repeat = false;
+            }
+        }
+
+        // finished k-means clustering
+        // the next part is borrowed from gabrielflor.it
+        const kClusters = {};
+        for (let j = 0; j < num; j++) {
+            kClusters[j] = [];
+        }
+        for (let i = 0; i < n; i++) {
+            cluster = assignments[i];
+            kClusters[cluster].push(values[i]);
+        }
+        let tmpKMeansBreaks = [];
+        for (let j = 0; j < num; j++) {
+            tmpKMeansBreaks.push(kClusters[j][0]);
+            tmpKMeansBreaks.push(kClusters[j][kClusters[j].length - 1]);
+        }
+        tmpKMeansBreaks = tmpKMeansBreaks.sort((a, b) => a - b);
+        limits.push(tmpKMeansBreaks[0]);
+        for (let i = 1; i < tmpKMeansBreaks.length; i += 2) {
+            const v = tmpKMeansBreaks[i];
+            if (!isNaN(v) && limits.indexOf(v) === -1) {
+                limits.push(v);
+            }
+        }
+    }
+    return limits;
+}

simview/static/lib/chroma-js-3.1.2/src/utils/clip_rgb.js

@@ -0,0 +1,15 @@
+import limit from './limit.js';
+
+export default (rgb) => {
+    rgb._clipped = false;
+    rgb._unclipped = rgb.slice(0);
+    for (let i = 0; i <= 3; i++) {
+        if (i < 3) {
+            if (rgb[i] < 0 || rgb[i] > 255) rgb._clipped = true;
+            rgb[i] = limit(rgb[i], 0, 255);
+        } else if (i === 3) {
+            rgb[i] = limit(rgb[i], 0, 1);
+        }
+    }
+    return rgb;
+};

simview/static/lib/chroma-js-3.1.2/src/utils/contrast.js

@@ -0,0 +1,12 @@
+import Color from '../Color.js';
+import '../ops/luminance.js';
+
+export default (a, b) => {
+    // WCAG contrast ratio
+    // see http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef
+    a = new Color(a);
+    b = new Color(b);
+    const l1 = a.luminance();
+    const l2 = b.luminance();
+    return l1 > l2 ? (l1 + 0.05) / (l2 + 0.05) : (l2 + 0.05) / (l1 + 0.05);
+};

simview/static/lib/chroma-js-3.1.2/src/utils/contrastAPCA.js

@@ -0,0 +1,68 @@
+import Color from '../Color.js';
+import mix from '../generator/mix.js';
+
+/**
+ * @license
+ *
+ * The APCA contrast prediction algorithm is based of the formulas published
+ * in the APCA-1.0.98G specification by Myndex. The specification is available at:
+ * https://raw.githubusercontent.com/Myndex/apca-w3/master/images/APCAw3_0.1.17_APCA0.0.98G.svg
+ *
+ * Note that the APCA implementation is still beta, so please update to
+ * future versions of chroma.js when they become available.
+ *
+ * You can read more about the APCA Readability Criterion at
+ * https://readtech.org/ARC/
+ */
+
+// constants
+const W_offset = 0.027;
+const P_in = 0.0005;
+const P_out = 0.1;
+const R_scale = 1.14;
+const B_threshold = 0.022;
+const B_exp = 1.414;
+
+export default (text, bg) => {
+    // parse input colors
+    text = new Color(text);
+    bg = new Color(bg);
+    // if text color has alpha, blend against background
+    if (text.alpha() < 1) {
+        text = mix(bg, text, text.alpha(), 'rgb');
+    }
+    const l_text = lum(...text.rgb());
+    const l_bg = lum(...bg.rgb());
+
+    // soft clamp black levels
+    const Y_text =
+        l_text >= B_threshold
+            ? l_text
+            : l_text + Math.pow(B_threshold - l_text, B_exp);
+    const Y_bg =
+        l_bg >= B_threshold ? l_bg : l_bg + Math.pow(B_threshold - l_bg, B_exp);
+
+    // normal polarity (dark text on light background)
+    const S_norm = Math.pow(Y_bg, 0.56) - Math.pow(Y_text, 0.57);
+    // reverse polarity (light text on dark background)
+    const S_rev = Math.pow(Y_bg, 0.65) - Math.pow(Y_text, 0.62);
+    // clamp noise then scale
+    const C =
+        Math.abs(Y_bg - Y_text) < P_in
+            ? 0
+            : Y_text < Y_bg
+              ? S_norm * R_scale
+              : S_rev * R_scale;
+    // clamp minimum contrast then offset
+    const S_apc = Math.abs(C) < P_out ? 0 : C > 0 ? C - W_offset : C + W_offset;
+    // scale to 100
+    return S_apc * 100;
+};
+
+function lum(r, g, b) {
+    return (
+        0.2126729 * Math.pow(r / 255, 2.4) +
+        0.7151522 * Math.pow(g / 255, 2.4) +
+        0.072175 * Math.pow(b / 255, 2.4)
+    );
+}

simview/static/lib/chroma-js-3.1.2/src/utils/delta-e.js

@@ -0,0 +1,62 @@
+import Color from '../Color.js';
+const { sqrt, pow, min, max, atan2, abs, cos, sin, exp, PI } = Math;
+
+export default function (a, b, Kl = 1, Kc = 1, Kh = 1) {
+    // Delta E (CIE 2000)
+    // see http://www.brucelindbloom.com/index.html?Eqn_DeltaE_CIE2000.html
+    var rad2deg = function (rad) {
+        return (360 * rad) / (2 * PI);
+    };
+    var deg2rad = function (deg) {
+        return (2 * PI * deg) / 360;
+    };
+    a = new Color(a);
+    b = new Color(b);
+    const [L1, a1, b1] = Array.from(a.lab());
+    const [L2, a2, b2] = Array.from(b.lab());
+    const avgL = (L1 + L2) / 2;
+    const C1 = sqrt(pow(a1, 2) + pow(b1, 2));
+    const C2 = sqrt(pow(a2, 2) + pow(b2, 2));
+    const avgC = (C1 + C2) / 2;
+    const G = 0.5 * (1 - sqrt(pow(avgC, 7) / (pow(avgC, 7) + pow(25, 7))));
+    const a1p = a1 * (1 + G);
+    const a2p = a2 * (1 + G);
+    const C1p = sqrt(pow(a1p, 2) + pow(b1, 2));
+    const C2p = sqrt(pow(a2p, 2) + pow(b2, 2));
+    const avgCp = (C1p + C2p) / 2;
+    const arctan1 = rad2deg(atan2(b1, a1p));
+    const arctan2 = rad2deg(atan2(b2, a2p));
+    const h1p = arctan1 >= 0 ? arctan1 : arctan1 + 360;
+    const h2p = arctan2 >= 0 ? arctan2 : arctan2 + 360;
+    const avgHp =
+        abs(h1p - h2p) > 180 ? (h1p + h2p + 360) / 2 : (h1p + h2p) / 2;
+    const T =
+        1 -
+        0.17 * cos(deg2rad(avgHp - 30)) +
+        0.24 * cos(deg2rad(2 * avgHp)) +
+        0.32 * cos(deg2rad(3 * avgHp + 6)) -
+        0.2 * cos(deg2rad(4 * avgHp - 63));
+    let deltaHp = h2p - h1p;
+    deltaHp =
+        abs(deltaHp) <= 180
+            ? deltaHp
+            : h2p <= h1p
+              ? deltaHp + 360
+              : deltaHp - 360;
+    deltaHp = 2 * sqrt(C1p * C2p) * sin(deg2rad(deltaHp) / 2);
+    const deltaL = L2 - L1;
+    const deltaCp = C2p - C1p;
+    const sl = 1 + (0.015 * pow(avgL - 50, 2)) / sqrt(20 + pow(avgL - 50, 2));
+    const sc = 1 + 0.045 * avgCp;
+    const sh = 1 + 0.015 * avgCp * T;
+    const deltaTheta = 30 * exp(-pow((avgHp - 275) / 25, 2));
+    const Rc = 2 * sqrt(pow(avgCp, 7) / (pow(avgCp, 7) + pow(25, 7)));
+    const Rt = -Rc * sin(2 * deg2rad(deltaTheta));
+    const result = sqrt(
+        pow(deltaL / (Kl * sl), 2) +
+            pow(deltaCp / (Kc * sc), 2) +
+            pow(deltaHp / (Kh * sh), 2) +
+            Rt * (deltaCp / (Kc * sc)) * (deltaHp / (Kh * sh))
+    );
+    return max(0, min(100, result));
+}

simview/static/lib/chroma-js-3.1.2/src/utils/distance.js

@@ -0,0 +1,17 @@
+import Color from '../Color.js';
+
+// simple Euclidean distance
+export default function (a, b, mode = 'lab') {
+    // Delta E (CIE 1976)
+    // see http://www.brucelindbloom.com/index.html?Equations.html
+    a = new Color(a);
+    b = new Color(b);
+    const l1 = a.get(mode);
+    const l2 = b.get(mode);
+    let sum_sq = 0;
+    for (let i in l1) {
+        const d = (l1[i] || 0) - (l2[i] || 0);
+        sum_sq += d * d;
+    }
+    return Math.sqrt(sum_sq);
+}

simview/static/lib/chroma-js-3.1.2/src/utils/index.js

@@ -0,0 +1,27 @@
+const { PI, min, max } = Math;
+
+const rnd2 = (a) => Math.round(a * 100) / 100;
+const rnd3 = (a) => Math.round(a * 100) / 100;
+
+export { default as clip_rgb } from './clip_rgb.js';
+export { default as limit } from './limit.js';
+export { default as type } from './type.js';
+export { default as unpack } from './unpack.js';
+export { default as last } from './last.js';
+
+const TWOPI = PI * 2;
+const PITHIRD = PI / 3;
+const DEG2RAD = PI / 180;
+const RAD2DEG = 180 / PI;
+
+/**
+ * Reverse the first three elements of an array
+ *
+ * @param {any[]} arr
+ * @returns {any[]}
+ */
+function reverse3(arr) {
+    return [...arr.slice(0, 3).reverse(), ...arr.slice(3)];
+}
+
+export { PI, TWOPI, PITHIRD, DEG2RAD, RAD2DEG, min, max, rnd2, rnd3, reverse3 };

simview/static/lib/chroma-js-3.1.2/src/utils/last.js

@@ -0,0 +1,8 @@
+import type from './type.js';
+
+export default (args) => {
+    if (args.length < 2) return null;
+    const l = args.length - 1;
+    if (type(args[l]) == 'string') return args[l].toLowerCase();
+    return null;
+};

simview/static/lib/chroma-js-3.1.2/src/utils/limit.js

@@ -0,0 +1,5 @@
+const { min, max } = Math;
+
+export default (x, low = 0, high = 1) => {
+    return min(max(low, x), high);
+};

simview/static/lib/chroma-js-3.1.2/src/utils/multiply-matrices.js

@@ -0,0 +1,36 @@
+// from https://www.w3.org/TR/css-color-4/multiply-matrices.js
+export default function multiplyMatrices(A, B) {
+    let m = A.length;
+
+    if (!Array.isArray(A[0])) {
+        // A is vector, convert to [[a, b, c, ...]]
+        A = [A];
+    }
+
+    if (!Array.isArray(B[0])) {
+        // B is vector, convert to [[a], [b], [c], ...]]
+        B = B.map((x) => [x]);
+    }
+
+    let p = B[0].length;
+    let B_cols = B[0].map((_, i) => B.map((x) => x[i])); // transpose B
+    let product = A.map((row) =>
+        B_cols.map((col) => {
+            if (!Array.isArray(row)) {
+                return col.reduce((a, c) => a + c * row, 0);
+            }
+
+            return row.reduce((a, c, i) => a + c * (col[i] || 0), 0);
+        })
+    );
+
+    if (m === 1) {
+        product = product[0]; // Avoid [[a, b, c, ...]]
+    }
+
+    if (p === 1) {
+        return product.map((x) => x[0]); // Avoid [[a], [b], [c], ...]]
+    }
+
+    return product;
+}

simview/static/lib/chroma-js-3.1.2/src/utils/scales.js

@@ -0,0 +1,15 @@
+// some pre-defined color scales:
+import chroma from '../chroma.js';
+import '../io/hsl/index.js';
+import scale from '../generator/scale.js';
+
+export default {
+    cool() {
+        return scale([chroma.hsl(180, 1, 0.9), chroma.hsl(250, 0.7, 0.4)]);
+    },
+    hot() {
+        return scale(['#000', '#f00', '#ff0', '#fff'], [0, 0.25, 0.75, 1]).mode(
+            'rgb'
+        );
+    }
+};

simview/static/lib/chroma-js-3.1.2/src/utils/type.js

@@ -0,0 +1,18 @@
+// ported from jQuery's $.type
+const classToType = {};
+for (let name of [
+    'Boolean',
+    'Number',
+    'String',
+    'Function',
+    'Array',
+    'Date',
+    'RegExp',
+    'Undefined',
+    'Null'
+]) {
+    classToType[`[object ${name}]`] = name.toLowerCase();
+}
+export default function (obj) {
+    return classToType[Object.prototype.toString.call(obj)] || 'object';
+}

simview/static/lib/chroma-js-3.1.2/src/utils/unpack.js

@@ -0,0 +1,17 @@
+import type from './type.js';
+
+export default (args, keyOrder = null) => {
+    // if called with more than 3 arguments, we return the arguments
+    if (args.length >= 3) return Array.prototype.slice.call(args);
+    // with less than 3 args we check if first arg is object
+    // and use the keyOrder string to extract and sort properties
+    if (type(args[0]) == 'object' && keyOrder) {
+        return keyOrder
+            .split('')
+            .filter((k) => args[0][k] !== undefined)
+            .map((k) => args[0][k]);
+    }
+    // otherwise we just return the first argument
+    // (which we suppose is an array of args)
+    return args[0].slice(0);
+};

simview/static/lib/chroma-js-3.1.2/src/utils/valid.js

@@ -0,0 +1,11 @@
+import Color from '../Color.js';
+
+export default (...args) => {
+    try {
+        new Color(...args);
+        return true;
+        // eslint-disable-next-line
+    } catch (e) {
+        return false;
+    }
+};

simview/static/lib/chroma-js-3.1.2/src/version.js

@@ -0,0 +1,2 @@
+// this gets updated automatically
+export const version = '3.1.2';

simview/static/lib/download.js

@@ -0,0 +1,132 @@
+//download.js v3.0, by dandavis; 2008-2014. [CCBY2] see http://danml.com/download.html for tests/usage
+// v1 landed a FF+Chrome compat way of downloading strings to local un-named files, upgraded to use a hidden frame and optional mime
+// v2 added named files via a[download], msSaveBlob, IE (10+) support, and window.URL support for larger+faster saves than dataURLs
+// v3 added dataURL and Blob Input, bind-toggle arity, and legacy dataURL fallback was improved with force-download mime and base64 support
+
+// data can be a string, Blob, File, or dataURL
+
+		 
+						 
+						 
+function download(data, strFileName, strMimeType) {
+	
+	var self = window, // this script is only for browsers anyway...
+		u = "application/octet-stream", // this default mime also triggers iframe downloads
+		m = strMimeType || u, 
+		x = data,
+		D = document,
+		a = D.createElement("a"),
+		z = function(a){return String(a);},
+		
+		
+		B = self.Blob || self.MozBlob || self.WebKitBlob || z,
+		BB = self.MSBlobBuilder || self.WebKitBlobBuilder || self.BlobBuilder,
+		fn = strFileName || "download",
+		blob, 
+		b,
+		ua,
+		fr;
+
+	//if(typeof B.bind === 'function' ){ B=B.bind(self); }
+	
+	if(String(this)==="true"){ //reverse arguments, allowing download.bind(true, "text/xml", "export.xml") to act as a callback
+		x=[x, m];
+		m=x[0];
+		x=x[1]; 
+	}
+	
+	
+	
+	//go ahead and download dataURLs right away
+	if(String(x).match(/^data\:[\w+\-]+\/[\w+\-]+[,;]/)){
+		return navigator.msSaveBlob ?  // IE10 can't do a[download], only Blobs:
+			navigator.msSaveBlob(d2b(x), fn) : 
+			saver(x) ; // everyone else can save dataURLs un-processed
+	}//end if dataURL passed?
+	
+	try{
+	
+		blob = x instanceof B ? 
+			x : 
+			new B([x], {type: m}) ;
+	}catch(y){
+		if(BB){
+			b = new BB();
+			b.append([x]);
+			blob = b.getBlob(m); // the blob
+		}
+		
+	}
+	
+	
+	
+	function d2b(u) {
+		var p= u.split(/[:;,]/),
+		t= p[1],
+		dec= p[2] == "base64" ? atob : decodeURIComponent,
+		bin= dec(p.pop()),
+		mx= bin.length,
+		i= 0,
+		uia= new Uint8Array(mx);
+
+		for(i;i<mx;++i) uia[i]= bin.charCodeAt(i);
+
+		return new B([uia], {type: t});
+	 }
+	  
+	function saver(url, winMode){
+		
+		
+		if ('download' in a) { //html5 A[download] 			
+			a.href = url;
+			a.setAttribute("download", fn);
+			a.innerHTML = "downloading...";
+			a.style.display = 'none';
+			D.body.appendChild(a);
+			setTimeout(function() {
+				a.click();
+				D.body.removeChild(a);
+				if(winMode===true){setTimeout(function(){ self.URL.revokeObjectURL(a.href);}, 250 );}
+			}, 66);
+			return true;
+		}
+		
+		//do iframe dataURL download (old ch+FF):
+		var f = D.createElement("iframe");
+		D.body.appendChild(f);
+		if(!winMode){ // force a mime that will download:
+			url="data:"+url.replace(/^data:([\w\/\-\+]+)/, u);
+		}
+		 
+	
+		f.src = url;
+		setTimeout(function(){ D.body.removeChild(f); }, 333);
+		
+	}//end saver 
+		
+
+	if (navigator.msSaveBlob) { // IE10+ : (has Blob, but not a[download] or URL)
+		return navigator.msSaveBlob(blob, fn);
+	} 	
+	
+	if(self.URL){ // simple fast and modern way using Blob and URL:
+		saver(self.URL.createObjectURL(blob), true);
+	}else{
+		// handle non-Blob()+non-URL browsers:
+		if(typeof blob === "string" || blob.constructor===z ){
+			try{
+				return saver( "data:" +  m   + ";base64,"  +  self.btoa(blob)  ); 
+			}catch(y){
+				return saver( "data:" +  m   + "," + encodeURIComponent(blob)  ); 
+			}
+		}
+		
+		// Blob but not URL:
+		fr=new FileReader();
+		fr.onload=function(e){
+			saver(this.result); 
+		};
+		fr.readAsDataURL(blob);
+	}	
+	return true;
+} /* end download() */