mascot-vis 3.0.0 → 3.0.1

package/src-old/core/Scale.js

@@ -1,322 +0,0 @@
-import * as d3 from 'd3';
-import { Errors, ScaleType, Warnings } from '../util/Constants';
-import { ItemCounter } from '../util/ItemUtil';
-import SceneValidator from './SceneValidator';
-
-
-export default class Scale {
-
-	constructor(type, args) {
-		if (ScaleType.indexOf(type) < 0) {
-			throw new Error(Errors.UNKOWNN_SCALE_TYPE + ": " + type);
-		}
-		this._type = type;
-		//offset in terms of absolute coordinates on screen, this property is useful for reusing scales on items that are not in a layout
-		this._offset = undefined;
-		this.id = "scale" + ItemCounter["scale"]++;
-		this._flipped = false;
-		this._includeZero = false;
-		switch (type) {
-			case "linear":
-				if (args) {
-					//mapping
-					let domain = Object.keys(args).map(d => parseFloat(d)).sort((a,b) => a - b),
-						range = domain.map(d => args[d]);
-					this._scale = d3.scaleLinear(domain, range);
-					if ("clamp" in args)
-						this._scale.clamp(args.clamp);
-					this._mapping = args;
-				} else {
-					this._scale = d3.scaleLinear();
-				}
-				break;
-			case "point":
-				this._scale = d3.scalePoint();
-				break;
-			case "ordinal":
-				this._scale = d3.scaleOrdinal();
-				break;
-			case "ordinalColor":
-				this._scale = d3.scaleOrdinal(args? args.size ? d3[args.scheme][args.size] : d3[args.scheme] : d3.schemeCategory10);
-				break;
-			case "power":
-				this._scale = d3.scalePow().exponent(2);
-				break;
-			case "sqrt":
-				this._scale = d3.scalePow().exponent(0.5);
-				break;
-			case "log":
-				this._scale = d3.scaleLog();
-				break;
-			case "identity":
-			case "time":
-				this._scale = d3.scaleTime();
-				break;
-			case "sequentialColor":
-			case "divergingColor":
-				if (args && typeof(args) == "string") {
-					this._scale = d3.scaleSequential(d3[args]);
-					this._scheme = args;
-				}
-				else
-					this._scale = d3.scaleSequential();
-				break;
-			default:
-				break;
-		}
-		this.encodings = [];
-	}
-
-	set scheme(s) {
-		if (this._type.indexOf("Color") < 0 && this._type !== "linear") return;
-		//TODO: need to verify the scheme is compatible with the data type and characteristics
-		let scale = d3.scaleSequential(d3[s]), domain = this._scale.domain();
-		if (Math.min(...domain) * Math.max(...domain) < 0) {
-			let abs = Math.max(Math.abs(Math.min(...domain)), Math.abs(Math.max(...domain)));
-			domain = [-abs, abs];
-		} 
-		scale.domain(domain);
-		this._scheme = s;
-		this._scale = scale;
-		if (this._type === "linear") {
-			this._type = this._scale.domain()[0] * this._scale.domain()[1] < 0 ? "divergingColor" : "sequentialColor";
-			if (this._mapping)
-				this._mapping = undefined;
-		}
-		for (let enc of this.encodings) {
-			if (enc._mapping)
-				enc._mapping = undefined;
-			enc._scheme = s;
-			enc._apply();
-		}
-	}
-
-	get scheme() {
-		return this._scheme;
-	}
-
-	get type() {
-		return this._type;
-	}
-
-	set type(t) {
-		let scale;
-		switch (t) {
-			case "linear":
-				scale = d3.scaleLinear();
-				break;
-			case "power":
-				scale = d3.scalePow().exponent(2);
-				break;
-			case "sqrt":
-				scale = d3.scalePow().exponent(0.5);
-				break;
-			case "log":
-				scale = d3.scaleLog();
-				break;
-			default:
-				break;
-		}
-		if (scale) {
-			this._type = t;
-			scale.domain(this._scale.domain()).range(this._scale.range());
-			this._scale = scale;
-			for (let enc of this.encodings) {
-				//enc._map();
-				enc._apply();
-			}
-			for (let enc of this.encodings) {
-				enc.scene._updateAncestorBounds(enc.item, enc.items);
-			}
-		} else {
-			console.warn(Warnings.UNSUPPORTED_SCALE_TYPE_CHANGE + t);
-		}
-	}
-
-	toJSON() {
-		let json = {};
-		json.type = this.type;
-		json.id = this.id;
-		json.offset = this._offset;
-		if (this._scheme)
-			json.scheme = this._scheme;
-		json.domain = this._scale.domain();
-		json.range = this.range;
-		json.clamp = this.clamp;
-		json.isFlipped = this.isFlipped;
-		json.includeZero = this.includeZero;
-		
-		if (this._mapping)
-			json.mapping = this._mapping;
-		if (this._baseItem)
-			json.baseItem = this._baseItem.id;
-		return json;
-	}
-
-	// static mergeDomain(d1, d2){
-	// 	return [Math.min(d1[0], d2[0]), Math.max(d1[1], d2[1])];
-	// }
-
-	//the argument s will be discarded, this scale will kept being used
-	//only internally used in encoding._map
-	_merge(s) {
-		if (this.type != s.type) {
-			throw Errors.DIFFERENT_SCALE_TYPE;
-		}
-		//let scale;
-		let newDomain, newRange;
-		switch (this.type) {
-			case "linear":
-			case "time":
-				newDomain = [Math.min(this.domain[0], s.domain[0]), Math.max(this.domain[1], s.domain[1])];
-				newRange = [0, this.map(newDomain[1]) - this.map(newDomain[0])];
-				break;
-			case "point":
-			case "ordinalColor":
-				newDomain = [...new Set(this.domain.concat(s.domain))];
-				//TODO: need to compute new range
-				newRange = [];
-				//scale = createScale("point");
-				//scale.domain = [...new Set(this.domain.concat(s.domain))];
-				break;
-			default:
-				console.log("TODO: merge scale type", this.type);
-				break;
-		}
-		this._scale.domain(newDomain);
-		this._scale.range(newRange);
-	}
-
-	get domain() {
-		//TODO: this._scale.domain contains the true data domain values,
-		//this getter returns a different domain depending on includeZero
-		if (this._includeZero) {
-			let d = this._scale.domain();
-			return [0, d[1]];
-		} else
-			return this._scale.domain();
-	}
-
-	set domain(d) {
-		this._scale.domain(d);
-		for (let enc of this.encodings) {
-			//enc._map();
-			enc._apply();
-		}
-	}
-
-	get range() {
-		return this._scale.range();
-	}
-
-	//disable setting range directly because scale ranges are internally represented as [0, extent], 
-	//to support this, the argument should be in real screen coordinates and need to do internal conversion
-	set range(r) {
-		//TODO: check r is a two-element array
-		this._scale.range(r);
-		for (let enc of this.encodings) {
-			//enc._map();
-			enc._apply();
-		}
-
-		for (let enc of this.encodings) {
-			enc.scene._updateAncestorBounds(enc.item, enc.items);
-		}
-	}
-
-	_setRange(r) {
-		//TODO: check r is a two-element array
-		this._scale.range(r);
-		SceneValidator.scaleRangeSet(this);
-	}
-
-	get clamp() {
-		if (this.type == "linear")
-			return this._scale.clamp();
-		else
-			return false;
-	}
-
-	set clamp(c) {
-		if (this.type == "linear")
-			this._scale.clamp(c);
-	}
-
-	set rangeExtent(e) {
-		//TODO: check e is a valid number
-		let r = this._scale.range();
-		this._setRange([r[0], r[0] + e]);
-		// if (r[0] < r[1])
-		// 	this._setRange([r[0], r[0] + e]);
-		// else
-		// 	this._setRange([r[1] + e, r[1]]);
-	}
-
-	get rangeExtent() {
-		let r = this._scale.range();
-		return Math.abs(r[1] - r[0]);
-	}
-
-	_addEncoding(b) {
-		if (this.encodings.indexOf(b) < 0)
-			this.encodings.push(b);
-	}
-
-	map(d) {
-		let s = this._scale.copy(), v;
-		s.domain(this.domain);
-		if (this._flipped) {
-			s.range(this._scale.range().reverse());
-		}
-		v = s(d);
-		if (typeof(v) === "number")
-			return Math.round(v);
-		else
-			return v;
-	}
-
-	//TODO: handle flip
-	invert(r) {
-		return this._scale.invert(r);
-	}
-
-	get offset() {
-		return this._offset;
-	}
-
-	set offset(s) {
-		this._offset = s;
-		for (let enc of this.encodings) {
-			enc._apply();
-		}
-	}
-
-	get isFlipped() {
-		return this._flipped;
-	}
-
-	set isFlipped(f) {
-		this._flipped = f;
-	}
-
-	get includeZero() {
-		return this._includeZero;
-	}
-
-	set includeZero(i) {
-		this._includeZero = i;
-		SceneValidator.scaleDomainSet(this);
-	}
-
-	get mapping() {
-		return this._mapping;
-	}
-
-	getEncodedChannels() {
-		let channels = {};
-		for (let enc of this.encodings) {
-			channels[enc.channel] = true;
-		} 
-		return Object.keys(channels);
-	}
-}

package/src-old/core/SceneLoader.js

@@ -1,290 +0,0 @@
-import Rectangle from "../basic/Rectangle";
-import AffixConstraint from "../constraint/AffixConstraint";
-import AlignConstraint from "../constraint/AlignConstraint";
-import DataScope from "../data/DataScope";
-import DataTable from "../data/DataTable";
-import Segment from "../item/Segment";
-import Vertex from "../item/Vertex";
-import { ItemType, LayoutType } from "../util/Constants";
-import { getLayout, isPath, ItemCounter } from "../util/ItemUtil";
-import Scale from "./Scale";
-import Scene from "../item/composite/Scene";
-import LinearGradient from "../basic/Gradient";
-
-export default class SceneLoader {
-
-    constructor() {
-        this.axes = {};
-        this.legends = [];
-        this.gridlines = [];
-        this.scales = {};
-        this.tables = {};
-    }
-
-    load(json) {
-        //console.log("saved", json);
-        let sceneArgs = {};
-        if (json.fillColor)
-            sceneArgs.fillColor = json.fillColor;
-        if (json.itemCounter) {
-            for (let t in json.itemCounter)
-                ItemCounter[t] = json.itemCounter[t];
-        }
-        let scn = new Scene(sceneArgs);
-        scn.id = json.id;
-        scn.type = json.type;
-        if (json.bounds)
-            scn._bounds = new Rectangle(json.bounds.left, json.bounds.top, json.bounds.width, json.bounds.height);
-
-        if (json.tables) {
-            for (let t in json.tables) {
-                this.tables[t] = new DataTable(json.tables[t].data, json.tables[t].url, json.tables[t].fieldTypes);
-                this.tables[t].id = json.tables[t].id;
-            }
-        }
-
-        for (let c of json.children) {
-            this._processItem(scn, c, scn);
-        }
-
-        if (json.scales) {
-            for (let s in json.scales)
-                this._loadScale(json.scales[s], scn);
-        }
-
-        if (json.encodings) {
-            for (let e of json.encodings) {
-                this._loadEncoding(e, scn);
-            }
-        }
-
-        if (json.constraints) {
-            for (let c in json.constraints)
-                this._loadConstraint(json.constraints[c], scn);
-        }
-
-        for (let a in this.axes) {
-            this._createGuide(scn, this.axes[a]);
-        }
-
-        for (let l of this.legends) {
-            this._createGuide(scn, l);
-        }
-
-        for (let l of this.gridlines) {
-            this._createGuide(scn, l);
-        }
-
-        //console.log("loaded", scn);
-        return scn;
-    }
-
-    _loadScale(s, scn) {
-        let scale;
-        // if (s.type === "sequentialColor" && s.scheme) {
-        if (s.type.indexOf("Color") > 0 && s.scheme) {
-            scale = new Scale(s.type, s.scheme);
-        } else {
-            scale = new Scale(s.type);
-            scale.range = s.range;
-        }
-        scale.domain = s.type == "time" ? s.domain.map(d => new Date(d)) : s.domain;
-        scale.id = s.id;
-        if ("offset" in s)
-            scale.offset = s.offset;
-        scale.isFlipped = s.isFlipped;
-        scale.clamp = s.clamp;
-        scale._mapping = s.mapping;
-        if ("includeZero" in s)
-            scale.includeZero = s.includeZero;
-        if ("baseItem" in s)
-            scale._baseItem = scn.getItem(s.baseItem);
-        this.scales[scale.id] = scale;
-        //console.log(scale.domain, scale.range);
-    }
-
-    _loadEncoding(enc, scene) {
-        if (enc.args.datatable)
-            enc.args.datatable = this.tables[enc.args.datatable];
-        if (enc.args.scale) {
-            enc.args.scale = this.scales[enc.args.scale];
-        }
-        //let item = scene.getItem(enc.anyItem);
-        let items = enc.items.map(d => scene.getItem(d));
-        scene._doEncode(items, enc.args);
-        scene._relayoutAncestors(items[0], items);
-    }
-
-    _createGuide(scene, guide) {
-        switch (guide.type) {
-            case ItemType.Axis:
-                if (guide.args.item) {
-                    guide.args.item = scene.getItem(guide.args.item);
-                }
-                scene.axis(guide.channel, guide.field, guide.args);
-                break;
-            case ItemType.Legend:
-                scene.legend(guide.channel, guide.field, guide.args);
-                break;
-            case ItemType.Gridlines:
-                if (guide.args.item) {
-                    guide.args.item = scene.getItem(guide.args.item);
-                }
-                scene.gridlines(guide.channel, guide.field, guide.args);
-                break;
-        }
-    }
-
-    _processItem(parent, itm, scene) {
-        switch (itm.type) {
-            case ItemType.Axis: {
-                let id = itm.classId ? itm.classId : itm.id;
-                if (itm.args.tickValues && itm.args.isDate) {
-                    itm.args.tickValues = itm.args.tickValues.map(d => new Date(d));
-                }
-                this.axes[id] = itm;
-                break;
-            }
-            case ItemType.Gridlines:
-                if (itm.args.values && itm.args.isDate) {
-                    itm.args.values = itm.args.values.map(d => new Date(d));
-                }
-                this.gridlines.push(itm);
-                break;
-            case ItemType.Legend:
-                this.legends.push(itm);
-                break;
-            case ItemType.Collection: {
-                let coll = scene.collection();
-                parent.addChild(coll);
-                this._loadGroup(coll, itm, scene);
-                break;
-            }
-            case ItemType.Group: {
-                let g = scene.group();
-                parent.addChild(g);
-                this._loadGroup(g, itm, scene);
-                break;
-            }
-            case ItemType.Glyph: {
-                let glyph = scene.glyph();
-                parent.addChild(glyph);
-                this._loadGroup(glyph, itm, scene);
-                break;
-            }
-            default:
-                this._loadMark(parent, itm, scene);
-                break;
-        }
-    }
-
-    _loadConstraint(c, scene) {
-        switch (c.type) {
-            case "affixation": {
-                let item = scene.getItem(c.item), baseItem = scene.getItem(c.baseItem);
-                let cstr = new AffixConstraint(item, baseItem, scene, c.channel, c.itemAnchor, c.baseAnchor, c.offset);
-                cstr.id = c.id;
-                scene.constraints[c.id] = cstr;
-                cstr.apply();
-                return cstr;
-            }
-            case "alignment": {
-                let items = c.items.map(d => scene.getItem(d));
-                let cstr = new AlignConstraint(items, c.direction);
-                cstr.id = c.id;
-                scene.constraints[c.id] = cstr;
-                cstr.apply();
-                return cstr;
-            }
-        }
-    }
-
-    _loadDataScope(ds) {
-        let scope = new DataScope(this.tables[ds.dt]);
-        for (let f in ds.f2v) {
-            scope._field2value[f] = ds.f2v[f];
-            scope._updateTuples(f, ds.f2v[f]);
-        }
-        return scope;
-    }
-
-    _loadGroup(coll, itm, scene) {
-        coll.id = itm.id;
-        if (itm.classId)
-            coll.classId = itm.classId;
-        if (itm.dataScope)
-            coll.dataScope = this._loadDataScope(itm.dataScope);
-        if (itm.children) {
-            for (let c of itm.children) {
-                this._processItem(coll, c, scene);
-            }
-        }
-        if (itm.layout) {
-            let l = this._loadLayout(itm.layout);
-            l.group = coll;
-            coll._layout = l;
-        }
-        if (itm.bounds)
-            coll._bounds = new Rectangle(itm.bounds.left, itm.bounds.top, itm.bounds.width, itm.bounds.height);
-    }
-
-    _loadMark(parent, itm, scene) {
-        if (itm.args.fillColor && itm.args.fillColor.type === "LinearGradient") {
-            let g = itm.args.fillColor;
-            itm.args.fillColor = new LinearGradient(g);
-            itm.args.fillColor.id = g.id;
-            itm.args.fillColor._stops = g.stops;
-        }
-        if ("id" in itm)
-            itm.args.id = itm.id;
-        let mark = scene.mark(itm.type, itm.args);
-        if (itm.classId)
-            mark.classId = itm.classId;
-        if (itm.dataScope)
-            mark.dataScope = this._loadDataScope(itm.dataScope);
-        if (itm.vertices) {
-            const vertices = [];
-            for (let d of itm.vertices) {
-                const v = Vertex.fromJSON(d, mark);
-                if (v.dataScope)
-                    v.dataScope = this._loadDataScope(v.dataScope);
-                vertices.push(v);
-            }
-            mark.vertices = vertices;
-            //TODO: modify instead of replace segments
-            mark.segments = [];
-            for (let i = 1; i < mark.vertices.length; i++)
-                mark.segments.push(new Segment(mark.vertices[i-1], mark.vertices[i], mark, mark.segmentCounter++));
-        }
-        if (itm.bounds)
-            mark._bounds = new Rectangle(itm.bounds.left, itm.bounds.top, itm.bounds.width, itm.bounds.height);
-        if (itm.boundsOffsets)
-            mark.boundsOffsets = itm.boundsOffsets;
-        if (isPath(mark)) {
-            mark.vertexCounter = itm.vertexCounter;
-            mark.segmentCounter = itm.segmentCounter;
-            mark.curveMode = itm.curveMode;
-        } else if (itm.type === ItemType.Image) {
-            mark.src = itm.src;
-            mark.width = itm.width;
-            mark.height = itm.height;
-            mark.x = itm.x;
-            mark.y = itm.y;
-        }
-        parent.addChild(mark);
-    }
-
-    _loadLayout(l) {
-        let lo = getLayout(l.type, l.args);
-        switch (l.type) {
-            case LayoutType.Grid:
-                lo._left = l.left;
-                lo._top = l.top;
-                break;
-            default:
-                break;
-        }
-        return lo;
-    }
-
-}