mascot-vis 3.0.0 → 3.0.1

package/src-old/data/Tree.js

@@ -1,251 +0,0 @@
-import { atlas_rowId, nodeId } from "../util/Constants";
-import DataScope from "./DataScope";
-import DataTable from "./DataTable";
-
-const depth = "_depth";
-
-export default class Tree {
-
-    constructor(data, name) {
-        this._type = "tree";
-        let nodeArr = [];
-        let linkArr = [];
-
-        this._nodeHash = {};
-
-        this._traverse(data, nodeArr, linkArr);
-
-        this._nodeTable = new DataTable(nodeArr, "nodes");
-        this._linkTable = new DataTable(linkArr, "links");
-
-        this._nodeTable.tree = this;
-        this._linkTable.tree = this;
-        this._data = data;
-        //this.aggregateFromLeaves("value", "average");
-    }
-
-    get type() {
-        return this._type;
-    }
-
-    _traverse(data, nodes, links, d = 0) {
-        let node = {};
-        if (!(nodeId in data))
-            data[nodeId] = "n" + nodes.length;
-        nodes.push(node);
-        data[depth] = d;
-    
-        for (let k in data) {
-            if (k == "children" && data[k] && data[k].length > 0) {
-                for (let c of data[k]) {
-                    let id = this._traverse(c, nodes, links, d + 1);
-                    links.push({
-                        parent: data[nodeId],
-                        child: id
-                    });
-                }
-            } else
-                node[k] = data[k];
-        }
-        this._nodeHash[node[nodeId]] = node;
-        return node[nodeId];
-    }
-
-    getParent(node) {
-        let id = node[nodeId];
-        let parentId;
-        let links = this._linkTable["data"]
-        let nodes = this._nodeTable["data"];
-
-        for (let i in links) {
-            if (links[i]["child"] == id) {
-                parentId = links[i]["parent"];
-                let index = nodes.findIndex(x => x[nodeId] == parentId);
-                return nodes[index];
-            }
-        }
-    }
-
-    getChildren(node) {
-        let id = node[nodeId];
-        let children = [];
-        let links = this._linkTable["data"]
-        let nodes = this._nodeTable["data"];
-        for (let i in links) {
-            if (links[i]["parent"] == id) {
-                let childId = links[i]["child"];
-                let index = nodes.findIndex(x => x[nodeId] == childId);
-                children.push(nodes[index]);
-            }
-        }
-        return children;
-    }
-
-    getNodeDataScope(node) {
-        let ds = new DataScope(this._nodeTable);
-        return ds.cross(atlas_rowId, node[atlas_rowId]);
-    }
-
-    getMaxDepth() {
-        return this._nodeTable["_fieldSummaries"][depth]["max"];
-    }
-
-    getRoot() {
-        let nodes = this._nodeTable["data"];
-        return nodes[0]; // Due to recursive appending of nodes, last one is root
-    }
-
-    get nodeTable() {
-        return this._nodeTable;
-    }
-
-    get linkTable() {
-        return this._linkTable;
-    }
-
-    getNode(id) {
-        return this._nodeTable["data"].filter(d => d[nodeId] == id)[0];
-    }
-
-    sumLeaves(root, attr) {
-        if (!root) return 0;
-        let id = root[nodeId];
-        let children = []
-        children = this.getChildren(root);
-
-        if (children && children.length > 0) {
-            let sum = 0;
-            for (let child of children) {
-                sum += this.sumLeaves(child, attr);
-            }
-            this.getNode(id)["sum" + attr] = sum;
-
-        } else this.getNode(id)["sum" + attr] = root[attr];
-        return root["sum" + attr];
-
-    }
-
-    countLeaves(root, attr) {
-        if (!root) return 0;
-        let id = root[nodeId];
-        let children = []
-        children = this.getChildren(root);
-        let count = 0;
-        if (children && children.length > 0) {
-            for (let child of children) {
-                count += this.countLeaves(child, attr);
-            }
-        } else {
-            count = 1
-        }
-        this.getNode(id)["count" + attr] = count;
-        return root["count" + attr];
-
-    }
-
-    averageLeaves(root, attr) {
-        if (!root) return 0;
-        let id = root[nodeId];
-        let children = []
-        children = this.getChildren(root);
-        let sum = 0;
-        if (children && children.length > 0) {
-            for (let child of children) {
-                sum += this.averageLeaves(child, attr);
-            }
-            sum /= children.length;
-            // this.getNode(id)["median" + attr]
-            this.getNode(id)["average" + attr] = sum;
-        } else this.getNode(id)["average" + attr] = root[attr];
-        return root["average" + attr];
-    }
-
-    medianLeaves(root, attr) {
-        if (!root) return 0;
-        let id = root[nodeId];
-        let children = []
-        children = this.getChildren(root);
-        let medianArr = [];
-        if (children && children.length > 0) {
-            for (let child of children) {
-                medianArr.push(this.medianLeaves(child, attr));
-            }
-            medianArr.sort(function (a, b) {
-                return a - b;
-            });
-
-            let mid = Math.floor(medianArr.length / 2);
-
-            if (medianArr.length % 2)
-                this.getNode(id)["median" + attr] = medianArr[mid];
-            else
-                this.getNode(id)["median" + attr] = (medianArr[mid - 1] + medianArr[mid]) / 2.0;
-        } else this.getNode(id)["median" + attr] = root[attr];
-        return root["median" + attr];
-
-    }
-
-    maxLeaves(root, attr) {
-        if (!root) return 0;
-        let id = root[nodeId];
-        let children = []
-        children = this.getChildren(root);
-        let Arr = [];
-        if (children && children.length > 0) {
-            for (let child of children) {
-                Arr.push(this.maxLeaves(child, attr));
-            }
-
-            this.getNode(id)["max" + attr] = Math.max(...Arr);
-        } else this.getNode(id)["max" + attr] = root[attr];
-
-        return root["max" + attr];
-    }
-
-    minLeaves(root, attr) {
-        if (!root) return 0;
-        let id = root[nodeId];
-        let children = []
-        children = this.getChildren(root);
-        let Arr = [];
-        if (children && children.length > 0) {
-            for (let child of children) {
-                Arr.push(this.minLeaves(child, attr));
-            }
-
-            this.getNode(id)["min" + attr] = Math.min(...Arr);
-        } else this.getNode(id)["min" + attr] = root[attr];
-        return root["min" + attr];
-
-    }
-
-    aggregateFromLeaves(attr, aggregator) {
-        let root = this.getRoot()
-        switch (aggregator) {
-
-            case "sum":
-                this.sumLeaves(root, attr);
-                break;
-
-            case "count":
-                this.countLeaves(root, attr);
-                break;
-
-            case "average":
-                this.averageLeaves(root, attr);
-                break;
-
-            case "median":
-                this.medianLeaves(root, attr);
-                break;
-
-            case "max":
-                this.maxLeaves(root, attr);
-                break;
-
-            case "min":
-                this.minLeaves(root, attr);
-        }
-    }
-
-}

package/src-old/data/transform/Bin.js

@@ -1,46 +0,0 @@
-import * as d3 from "d3";
-import { DataType } from "../../util/Constants";
-import DataTable from "../DataTable";
-
-export default function bin(table, fields, args) {
-	//right now only handles one field
-    let f = fields[0];
-    //TODO: check that can perform kde on f
-    let gf = table.nonNumericFields;
-
-    //construct groups
-    let g = {};
-    for (let row of table.data){
-        let k = gf.map(d => String(row[d])).join("_");
-        if (!g.hasOwnProperty(k)){
-            g[k] = gf.map(d => row[d]);
-            g[k].push([]);
-        }  
-        g[k][g[k].length -1].push(row[f]);
-    }
-
-    let newData = [];
-    for (let k in g) {
-        let data = g[k].pop(), 
-            bin = d3.bin()(data);
-        for (let b of bin) {
-            let o = {};
-            g[k].forEach((d, i) => o[gf[i]] = d);
-            o["x0"] = b.x0;
-            o["x1"] = b.x1;
-            o[f+"_count"] = b.length;
-            newData.push(o);
-        }
-    }
-
-    let fTypes = {};
-    gf.forEach(d => fTypes[d] = table.getFieldType(d));
-    fTypes["x0"] = DataType.Number;
-    fTypes["x1"] = DataType.Number;
-    fTypes[f+"_count"] = DataType.Number;
-
-    let dt = new DataTable(newData, table.url, fTypes);
-    dt.sourceDataTable = table;
-    dt.transform = {"type": "bin", "args": fields};
-    return dt;
-}

package/src-old/data/transform/Filter.js

@@ -1,48 +0,0 @@
-import DataTable from "../DataTable";
-
-export default function filter(table, predicates) {
-    let data = [];
-    for (let row of table.data){
-        let include = true;
-        for (let p of predicates){
-            if (!satisfy(row, p)){
-                include = false;
-                break;
-            }
-        }
-        if (include)
-            data.push(row);
-    }
-    let dt = new DataTable(data, table.url);
-    dt.sourceDataTable = table;
-    dt.transform = {"type": "filter", "args": predicates};
-    return dt;
-}
-
-function satisfy(row, p){
-    if ("field" in p) {
-        let f = p["field"];
-        if ("value" in p)
-            return row[f] == p["value"];
-        else if ("range" in p)
-            return row[f] >= p["range"][0] && row[f] <= p["range"][1];
-        else if ("values" in p)
-            return p["values"].indexOf(row[f]) >= 0;
-    } else if ("fields" in p) {
-        let f1 = p["fields"][0], f2 = p["fields"][1],
-            v1 = row[f1], v2 = row[f2];
-        switch (p["operator"]) {
-			case "==":
-				return v1 == v2;
-			case ">":
-				return v1 > v2;
-			case ">=":
-				return v1 >= v2;
-			case "<":
-				return v1 < v2;
-			case "<=":
-				return v1 <= v2;
-		}
-        return false;
-    }
-}

package/src-old/data/transform/Groupby.js

@@ -1,18 +0,0 @@
-export default function groupby (table, fields) {
-    let g = {};
-    for (let row of table.data){
-        addGroupByVals(fields, row, g);
-    }
-}
-
-function addGroupByVals(fields, row, obj){
-    // let hash = obj;
-    // for (let i = 0; i < fields.length; i++){
-    //     if (!hash.hasOwnProperty(vals[i]))
-    //         hash[vals[i]] = i == fields.length - 1 ? [] : {};
-    //     if (i == fields.length - 1)
-    //         hash[vals[i]].push(row);
-    //     else
-    //         hash = hash[vals[i]];
-    // }
-}

package/src-old/data/transform/KDE.js

@@ -1,58 +0,0 @@
-import * as d3 from "d3";
-import { DataType } from "../../util/Constants";
-import DataTable from "../DataTable";
-
-export default function kde(table, fields, args) {
-	//right now only handles one field
-    let f = fields[0];
-    //TODO: check that can perform kde on f
-    let gf = table.nonNumericFields;
-
-    let g = {};
-    for (let row of table.data){
-        let k = gf.map(d => String(row[d])).join("_");
-        if (!(k in g)){
-            g[k] = gf.map(d => row[d]);
-            g[k].push([]);
-        }  
-        g[k][g[k].length -1].push(row[f]);
-    }
-    
-    let min = ("min" in args) ? args.min : table.getFieldSummary(f).min,
-        max = ("max" in args) ? args.max : table.getFieldSummary(f).max;
-    let v = min, thresholds = [];
-    while(v < max) {
-        thresholds.push(v);
-        v += args["interval"];
-    }
-    thresholds.push(v);
-
-    let newData = [];
-    for (let k in g) {
-        let data = g[k].pop(), 
-            density = _kde(_epanechnikov(args.bandwidth), thresholds, data);
-        for (let t of density) {
-            let o = {};
-            g[k].forEach((d, i) => o[gf[i]] = d);
-            o[f] = t[0];
-            o[f+"_density"] = t[1];
-            newData.push(o);
-        }
-    }
-
-    let fTypes = {};
-    gf.forEach(d => fTypes[d] = table.getFieldType(d));
-    fTypes[f] = DataType.Number;
-    fTypes[f+"_density"] = DataType.Number;
-
-    return new DataTable(newData, table.url, fTypes);
-}
-
-function _kde(kernel, thresholds, data) {
-    return thresholds.map(t => [t, d3.mean(data, d => kernel(t - d))]);
-}
-
-function _epanechnikov(bandwidth) {
-    return x => Math.abs(x /= bandwidth) <= 1 ? 0.75 * (1 - x * x) / bandwidth : 0;
-}
-

package/src-old/data/transform/Sort.js

@@ -1,14 +0,0 @@
-export default function sort(table, fields, args) {
-    table.data.sort((a,b) => compareRow(a,b, fields));
-    table.summarize();
-}
-
-function compareRow(row1, row2, fields, fieldTypes){
-    for (let f of fields){
-        if (row1[f] < row2[f])
-            return -1;
-        else if (row1[f] > row2[f])
-            return 1;
-    }
-    return 0;
-}

package/src-old/data/transform/Split.js

@@ -1,5 +0,0 @@
-import groupby from "./Groupby";
-
-export default function split(table, fields, args) {
-    groupby(table, fields);
-}

package/src-old/data/transform/partition.js

@@ -1,46 +0,0 @@
-import { nodeId } from "../../util/Constants";
-import Network from "../Network";
-
-function merge(grouping, subgraphs) {
-    let newGrouping = [grouping[0]], newSG = [subgraphs[0]];
-    for (let i = 1; i < subgraphs.length; i++) {
-        let canMerge = false, sg1 = subgraphs[i];
-        for (let j = 0; j < newSG.length; j++) {
-            let sg2 = newSG[j];
-            let set = new Set(sg1);
-            sg2.forEach(d => set.add(d));
-            if (set.size < sg1.length + sg2.length) {
-                newSG[j] = [...set];
-                newGrouping[j] = newGrouping[j].concat(grouping[i])
-                canMerge = true;
-                break;
-            }
-        }
-        if (!canMerge) {
-            newSG.push(sg1);
-            newGrouping.push(grouping[i]);
-        }
-    }
-    return {grouping: newGrouping, subgraphs: newSG};
-}
-
-export default function partition(graph) {
-    let nodes = graph.nodes, links = graph.links;
-    let grouping = links.map((d, i) => [i]), subgraphs = links.map((d) => [d.source, d.target]);
-    let newGrouping = merge(grouping, subgraphs);
-    while (newGrouping.grouping.length != grouping.length) {
-        grouping = newGrouping.grouping;
-        subgraphs = newGrouping.subgraphs;
-        newGrouping = merge(grouping, subgraphs);
-    }
-
-    let result = [];
-    for (let [i, g] of newGrouping.grouping.entries()) {
-        let data = {"nodes": [], "links": []};
-        data.links = g.map(d => links[d]);
-        const nids = newGrouping.subgraphs[i];
-        data.nodes = nodes.filter( d => nids.indexOf(d[nodeId]) >= 0 );
-        result.push(new Network(data));
-    }
-    return result;
-}