mascot-vis 3.0.0 → 3.0.2

package/src-old/bind/bindToThickness.js

@@ -1,100 +0,0 @@
-/** 
- * Binding data to thickness for arcs and rings
-*/
-import {DataType} from "../util/Constants";
-import ArcPath from "../item/mark/ArcPath";
-import Scale from "../core/Scale";
-
-function addToTree(node, arc) {
-	let itm = node.item;
-	if (arc.innerRadius === itm.outerRadius && itm.sweepOver(arc)) {
-		node.children.push({item: arc, children: []});
-		return;
-	} else if (node.children && node.children.length > 0 && arc.innerRadius > itm.outerRadius && itm.sweepOver(arc)) {
-		for (let c of node.children)
-			addToTree(c, arc);
-	}
-}
-
-function accumulateThickness(node, offset, data, scale) {
-	let itm = node.item;
-	itm.innerRadius = offset;
-	itm.outerRadius = offset + scale.map(data[itm.id]);
-	if (node.children && node.children.length > 0) {
-		for (let c of node.children) {
-			accumulateThickness(c, itm.outerRadius, data, scale);
-		}
-	}
-}
-
-export function bindToThickness(encoding){
-
-    encoding._query = function() {
-        this.data = {};
-		
-		let field = this.field, items = this.items;
-		let dataScopes = items.map(d => d.dataScope);
-
-		switch (this.datatable.getFieldType(field)) {
-			case DataType.Boolean:
-				break;
-
-			case DataType.Date:
-				for (let i = 0; i < items.length; i++) {
-					this.data[items[i].id] = dataScopes[i].getFieldValue(field);
-				}
-				//this.data = dataScopes.map(d => d.getFieldValue(field));
-				break;
-
-			case DataType.String:
-				try {
-					for (let i = 0; i < items.length; i++) {
-						this.data[items[i].id] = dataScopes[i].getFieldValue(field);
-					}
-					//this.data = dataScopes.map(d => d.getFieldValue(field));
-				} catch (error) {
-					throw new Error("Cannot bind " + this.channel + " to " + field + " : " + error);
-				}
-				break;
-
-			default: //integer or number
-				for (let i = 0; i < items.length; i++) {
-					this.data[items[i].id] = dataScopes[i].aggregateNumericalField(field, this.aggregator);
-				}
-				//this.data = dataScopes.map(d => d.aggregateNumericalField(field, this.aggregator));
-				break;
-		}
-    }
-
-    encoding._map = function() {
-		let data = this.data;
-		if (!this.scale){
-			this.scale = new Scale(this.scaleType);
-			this.scale.domain = [0, Math.max(...Object.values(data))];
-			let min = 1, max = this.rangeExtent ? min + this.rangeExtent : Math.max(...(this.items.map(d => d.outerRadius)));
-			this.scale._setRange([min, max]);
-		}
-		this.scale._addEncoding(this);
-	}
-
-	
-
-    encoding._apply = function() {
-		//sort items by centroid
-		this.items.sort((a, b) => (a.innerRadius+a.outerRadius)/2 - (b.innerRadius+b.outerRadius)/2);
-		let outer = Math.min(...this.items.map(d => d.innerRadius));
-		let tree = {item: new ArcPath({outerRadius: outer, startAngle: 0, endAngle: 360}), children: []};
-		for (let itm of this.items) {
-			addToTree(tree, itm);
-		}
-		
-		for (let node of tree.children)
-			accumulateThickness(node, node.item.innerRadius, this.data, this.scale);
-
-		// //relayout if needed
-		// this.scene._relayoutAncestors(this.anyItem, this.items);
-	}
-
-    encoding.run();
-	return encoding;
-}

package/src-old/constraint/AffixConstraint.js

@@ -1,129 +0,0 @@
-import { ConstraintType, ItemType } from "../util/Constants";
-import { getPeers } from "../util/ItemUtil";
-
-export default class AffixConstraint {
-
-    constructor(item, baseItem, scene, channel, itemAnchor, baseAnchor, offset) {
-        this.item = item;
-        this.baseItem = baseItem;
-        this.scene = scene;
-        this.channel = channel;
-        this.itemAnchor = itemAnchor;
-        this.baseAnchor = baseAnchor;
-        this.offset = offset;
-        this.type = ConstraintType.Affix;
-        this.id = this.type + "_" + this.item.classId + "_" + this.baseItem.classId + "_" + channel;
-    }
-
-    apply() {
-        let items = getPeers(this.item, this.scene), baseItems = getPeers(this.baseItem, this.scene);
-        //console.log(items.map(d => d.text), baseItems.map(d => d.dataScope.getFieldValue("event_attribute")));
-        let ia = this.itemAnchor,
-            ba = this.baseAnchor;
-
-        let isText = this.item.type == ItemType.PointText ? true : false;
-        if (this.channel == "radialDistance") {
-            for (let i = 0; i < items.length; i++) {
-                let dist, base = baseItems[i], item = items[i];
-                if (base.type == ItemType.Arc || base.type == ItemType.Ring)
-                    dist = ba == "top" ? base.outerRadius + this.offset : ba == "bottom" ? base.innerRadius + this.offset : (base.outerRadius + base.innerRadius)/2 + this.offset;
-                else if (base.type == ItemType.Circle)
-                    dist = ba == "top" ? base.radius + this.offset : ba == "bottom" ? this.offset : base.radius/2 + this.offset;
-                item._doTranslate( base.x - item.x, base.y - dist - item.bounds[ia] );
-                if (item._rotate) {
-                    item._rotate = [item._rotate[0], base.x, base.y];
-                } else {
-                    item._rotate = [0, base.x, base.y];
-                }
-            }
-        } else if (this.channel == "angle") {
-            for (let i = 0; i < items.length; i++) {
-                let angle, base = baseItems[i], item = items[i];
-                if (base.type == ItemType.Arc) {
-                    angle = ba == "left" ? base.endAngle + this.offset : ba == "center" ?  base.startAngle + base.angle/2 + this.offset : base.startAngle + this.offset;
-                } else {
-                    angle = 90;
-                }
-                // switch (ba) {
-                //     case "left":
-                //         angle = base.endAngle ? base.endAngle + this.offset : 90;
-                //         break;
-                //     case "center":
-                //         angle = base.startAngle ? base.startAngle + base.angle/2 + this.offset : 90;
-                //         break;
-                //     case "right":
-                //         angle = base.startAngle ? base.startAngle + this.offset : 90;
-                //         break;
-                // }
-                if (item._rotate) {
-                    item._rotate[0] = 90 - angle;
-                } else {
-                    item._doTranslate( base.x - item.bounds[ia], base.y - items[i].y );
-                    item._rotate = [90 - angle, baseItems[i].x, baseItems[i].y];
-                }
-            }
-        } else {
-            let frac;
-            if (this.baseItem.type == ItemType.Link) {
-                switch(ba) {
-                    case "left":
-                    case "top":
-                        frac = 0;
-                        break;
-                    case "center":
-                    case "middle":
-                        frac = 0.5;
-                        break;
-                    case "right":
-                    case "bottom":
-                        frac = 1;
-                        break;
-                }
-            }
-            for (let i = 0; i < items.length; i++) {
-                let p = this.baseItem.type == ItemType.Link ? baseItems[i].getPointAt(frac)[this.channel] : baseItems[i].bounds[ba] + this.offset;
-                if (isText) {
-                    items[i].anchor[this.channel == "x" ? 0 : 1] = this.itemAnchor;
-                    items[i][this.channel] = p;
-                } else {
-                    if (this.channel == "x")
-                        items[i]._doTranslate(p - items[i].bounds[ia], 0);
-                    else
-                        items[i]._doTranslate(0, p - items[i].bounds[ia]);
-                }
-            }
-        }
-        
-        this.item.getScene()._updateAncestorBounds(this.item);
-        this.baseItem.getScene()._updateAncestorBounds(this.baseItem); 
-        
-        // if (isText) {
-        //     for (let i = 0; i < items.length; i++) {
-        //         items[i].anchor[this.channel == "x" ? 0 : 1] = this.itemAnchor;
-        //         let p = baseItems[i].bounds[ba] + this.offset;
-        //         items[i][this.channel] = p;
-        //     }
-        // } else {
-        //     for (let i = 0; i < items.length; i++) {
-        //         let d = baseItems[i].bounds[ba] + this.offset - items[i].bounds[ia];
-        //         if (this.channel == "x")
-        //             items[i]._doTranslate(d, 0);
-        //         else
-        //             items[i]._doTranslate(0, d);
-        //     }
-        // }
-    }
-
-    toJSON() {
-        let json = {};
-        json.item = this.item.id;
-        json.baseItem = this.baseItem.id;
-        json.channel = this.channel;
-        json.itemAnchor = this.itemAnchor;
-        json.baseAnchor = this.baseAnchor;
-        json.offset = this.offset;
-        json.type = "affixation";
-        json.id = this.id;
-        return json;
-    }
-}

package/src-old/constraint/AlignConstraint.js

@@ -1,58 +0,0 @@
-import { Alignment, ConstraintType, LayoutType, Orientation } from "../util/Constants";
-import * as d3 from "d3";
-
-export default class AlignConstraint {
-
-    constructor(items, d) {
-        //TODO: check if d is a value in the Alignment (refer to const Alignment in Constants.js)
-        //if not, throw a new error (add an error type in Errors, also defined in Constants.js)
-
-        this.direction = d;
-        this.items = items;
-        this.type = ConstraintType.Align;
-        this._orientation = [Alignment.Top, Alignment.Middle, Alignment.Bottom].indexOf(d) >= 0 ? Orientation.Vertical : Orientation.Horizontal;
-        this._itemIds = this.items.map(d => d.classId).sort().join("_");
-        this.id = this.type + "_" + this._itemIds + "_" + this._orientation;
-    }
-
-    get orientation() {
-        return this._orientation;
-    }
-
-    apply() {
-        let baseline, dir = this.direction; 
-        if (this.direction == Alignment.Top || this.direction == Alignment.Left)
-            baseline = Math.min(...this.items.map(d => d.bounds[dir]));
-        else if ((this.direction == Alignment.Bottom || this.direction == Alignment.Right))
-            baseline = Math.max(...this.items.map(d => d.bounds[dir]));
-        else if (this.direction == Alignment.Center || this.direction == Alignment.Middle)
-            baseline = d3.mean(this.items.map(d => d.bounds[dir]));
-        
-        let delta = this.items.map(d => baseline - d.bounds[dir]),
-            axis = dir == Alignment.Top || dir == Alignment.Middle || dir == Alignment.Bottom ? "y" : "x";
-        this.items.forEach((d,i) => {
-            if (d.parent && d.parent.layout && d.parent.layout.type == LayoutType.Stack){
-                let dx = axis == "x" ? delta[i] : 0,
-                    dy = axis == "y" ? delta[i] : 0;
-                d.parent._doTranslate(dx, dy);
-            } else {
-                let dx = axis == "x" ? delta[i] : 0,
-                    dy = axis == "y" ? delta[i] : 0;
-                d._doTranslate(dx, dy);
-            }
-        });
-        //TODO:  update bounds
-        let itms = {};
-        this.items.forEach(d => itms[d.classId] = d);
-        Object.values(itms).forEach(d => d.getScene()._updateAncestorBounds(d)); 
-    }
-
-    toJSON() {
-        let json = {};
-        json.items = this.items.map(d => d.id);
-        json.direction = this.direction;
-        json.type = this.type;
-        json.id = this.id;
-        return json;
-    }
-}

package/src-old/core/Encoding.js

@@ -1,336 +0,0 @@
-import {getPeers, getClosestLayout, getTopLevelLayout, CheckAreaOrien, getCellBoundsInGridLayout, getEncodingKey, getTopLevelCollection, isMark} from "../util/ItemUtil";
-import {Alignment, DataType, LayoutType} from "../util/Constants";
-import {ItemType, Orientation} from "../util/Constants";
-import * as d3 from 'd3'; 
-
-export default class Encoding {
-
-	constructor(items, scene, channel, field, args) {
-		this.items = items;
-		this.anyItem = this.items[0];
-		this._axes = [];
-		this.scene = scene;
-		this.channel = channel;
-		this.field = field;
-		this._aggregator = args.aggregator;
-		this.datatable = args.datatable;
-		this.scale = args.scale;
-		//flipScale, scale type and includeZero will be ignored if reusing a scale
-		//these should be considered properties of a scale, not encoding
-		//same for scheme and mapping
-		if (this.scale) {
-			this._flipScale = this.scale.isFlipped;
-			this.scaleType = this.scale.type;
-			this._includeZero = this.scale.includeZero;
-		} else {
-			this._flipScale = args.flipScale;
-			this.scaleType = args.scaleType;
-			this._includeZero = args.includeZero;
-		}
-		this._mapping = args.mapping;
-		this.rangeExtent = args.rangeExtent;
-		this._scheme = args.scheme;
-		this.range = args.range;
-
-		if (this.channel == "angle") {
-			this.startAngle = "startAngle" in args ? args.startAngle : 90;
-			// this.angleDirection = "angleDirection" in args ? args.angleDirection : "clockwise";
-		}
-
-		//get the data needed for the mapping
-		this._query = undefined;
-
-		//construct/modify scales
-		this._map = undefined;
-
-		//apply mapping
-		this._apply = undefined;
-	}
-
-	get axes() {
-		return this._axes;
-	}
-
-	get id() {
-		return ["enc", getEncodingKey(this.anyItem), this.channel, this.field].join("-");
-	}
-
-	set aggregator(a) {
-		this._aggregator = a;
-		//this.scale = undefined;
-		this.run();
-	}
-
-	get aggregator() {
-		return this._aggregator;
-	}
-
-	toJSON() {
-		let json = {};
-		json.anyItem = this.anyItem.id;
-		json.items = this.items.map(d => d.id);
-		if (this.data)
-			json.data = this.data;
-		if (this._rectNegativeValues)
-			json._rectNegativeValues = true;
-		json.args = {};
-		json.args.channel = this.channel;
-		json.args.field = this.field;
-		json.args.aggregator = this.aggregator;
-		json.args.datatable = this.datatable.id;
-		json.args.scale = this.scale.id;
-		//json.args.includeZero = this._includeZero;
-		//json.args.flip = this.flip;
-		json.args.mapping = this._mapping;
-		json.args.rangeExtent = this.rangeExtent;
-		json.args.scheme = this._scheme;
-		json.args.scaleType = this.scaleType;
-		json.args.range = this.range;
-
-		if (this.channel == "angle") {
-			json.args.startAngle = this.startAngle;
-			//json.args.angleDirection = this.angleDirection;
-		}
-
-		return json;
-	}
-
-	run() {
-		this._query();
-		this._map();
-		this._apply();
-	}
-
-	get dataTable() {
-		return this.datatable;
-	}
-
-	_inferTickValues() {
-        let enc = this, domain = enc.scale.domain, range = enc.scale.range;
-		// if (this.datatable.getFieldType(this.field) == DataType.String)
-		// 	return domain;
-		let minPxInterval;
-		//let minTickIntervalPx = 40, minLabelIntervalPx = 80;
-		switch (enc.scale.type) {
-			case "linear":
-			case "log": {
-				//handle the case where the marks are stacked
-				let r = Math.abs(range[0] - range[1]);
-				if (enc.channel == "width" || enc.channel == "height") {
-					// let layout = getClosestLayout(enc.anyItem);
-					// if (layout && layout.type == LayoutType.Stack) {
-					// 	let c = layout.group, colls = getPeers(c, enc.scene);
-					// 	r = Math.max(...colls.map(d => d.bounds[enc.channel])) ;
-					// 	domain[1] = enc.scale.invert(r); // Math.ceil(enc.scale.invert(r)); do not ceil, it can amplify small difference in invert calculation due to imprecision/roundoff in bounding box calculation
-					// }
-					let layout = getTopLevelLayout(enc.anyItem, "stack");
-					if (layout) {
-						let c = layout.group, colls = getPeers(c, enc.scene);
-						r = Math.max(...colls.map(d => d.refBounds[enc.channel]));
-						domain[1] = enc.scale.invert(r); // Math.ceil(enc.scale.invert(r)); do not ceil, it can amplify small difference in invert calculation due to imprecision/roundoff in bounding box calculation
-					}
-				} 
-				minPxInterval = enc.channel == "width" || enc.channel == "x" ? 45 : 30;
-				let n = Math.max(2, Math.floor(r/minPxInterval));
-				let ticks;
-				if (enc.scale.type === "log") {
-					ticks = [];
-					let d3Ticks = enc.scale._scale.ticks();
-					//number of ticks is not configurable for d3 log scales,
-					//use the solution posted here: https://github.com/d3/d3/issues/72
-					for (let d of d3Ticks) {
-						let x = Math.log(d) / Math.log(10) + 1e-6;
-						if (Math.abs(x - Math.floor(x)) < n/d3Ticks.length)
-							ticks.push(d);
-					}
-				} else {
-					ticks = d3.ticks(domain[0], domain[1], n);
-				}
-				return ticks;
-			}
-			case "point": {
-				minPxInterval = enc.channel == "width" || enc.channel == "x" ? 80 : 30;
-				let domainValueIntervalPx = Math.floor(enc.scale.rangeExtent/domain.length);
-				let m = Math.ceil(minPxInterval/domainValueIntervalPx);
-				return enc.channel == "x" ? domain.filter((d, i) => i % m == 0) : domain;
-			}
-			case "time": {
-				minPxInterval = enc.channel == "width" || enc.channel == "x" ? 80 : 30;
-				let numIntervals = Math.floor((range[1] - range[0])/minPxInterval),
-					timeInterval = Math.ceil( (domain[1] - domain[0])/numIntervals )/1000;
-
-				let units = [1, 60, 3600, 86400, 2628003, 31536000],
-					intervals = [d3.timeSeconds, d3.timeMinutes, d3.timeHours, d3.timeDays, d3.timeMonths, d3.timeYears];
-
-				let tn, tInterval;
-				for (let i = 0; i < units.length - 1; i++) {
-					if (timeInterval >= units[i] && timeInterval < units[i+1]) {
-						tn = Math.floor(timeInterval/units[i]);
-						tInterval = intervals[i];
-						return tInterval(domain[0], domain[1], tn);
-					}
-				} 
-				if (timeInterval > units[units.length-1]) {
-					tn = Math.floor(timeInterval/units[units.length-1]);
-					tInterval = intervals[units.length-1];
-					return tInterval(domain[0], domain[1], tn);
-				}
-				return [];
-			}
-			default:
-				return [];
-		}
-    }
-
-	//optional itm specifies which scale range to get in the case of small multiples
-	getScaleRange(itm) {
-		let item = itm ? itm : this.anyItem;
-		if (item.type == ItemType.Area || (item.type == "vertex" && item.parent.type == ItemType.Area)) {
-			let area = item.type == ItemType.Area ? item : item.parent;
-			let AreaOrientation = CheckAreaOrien(area);
-			let layout = getClosestLayout(area);
-			let alignment;
-			if (layout) {
-				if (AreaOrientation == Orientation.Vertical) {
-					alignment = layout.horzCellAlignment === Alignment.Left;
-				} else {
-					alignment = layout.vertCellAlignment === Alignment.Bottom;
-				}
-				// alignment = AreaOrientation == Orientation.Vertical ? 
-				// 				(layout.type == LayoutType.Stack ? 
-				// 					layout._horzCellAlignment == Alignment.Left : layout._cellHorzAlignment == Alignment.Left) 
-				// 				: (layout.type == LayoutType.Stack ? layout._vertCellAlignment == Alignment.Bottom : layout._cellVertAlignment == Alignment.Bottom)
-			}
-			else {
-				alignment = AreaOrientation == Orientation.Vertical ? area.baseline == Alignment.Left : area.baseline == Alignment.Bottom;
-			}
-			// let DomainToBaseline = this.scale.domain[1] > this.scale.domain[0] ? "default" : "opposite"; // controlling the alignment for the axis and the chart
-			let cb = getCellBoundsInGridLayout(area);
-			if (cb) {
-				switch (this.channel) {
-					case "x":
-						return [cb.left, cb.left + this.scale.rangeExtent];
-					case "width":
-						return alignment ? [cb.left, cb.left + this.scale.rangeExtent] : [cb.right, cb.right - this.scale.rangeExtent];
-					case "y":
-						return [cb.bottom, cb.bottom - this.scale.rangeExtent];
-					case "height":
-						return alignment ? [cb.bottom, cb.bottom - this.scale.rangeExtent] : [cb.top + this.scale.rangeExtent, cb.top];
-				}
-			} else if (layout && layout.type === "stack") {
-				cb = layout.group.bounds;
-				switch (this.channel) {
-					case "x":
-						return [cb.left, cb.left + this.scale.rangeExtent];
-					case "width":
-						return alignment ? [cb.left, cb.left + this.scale.rangeExtent] : [cb.right, cb.right - this.scale.rangeExtent];
-					case "y":
-						return [cb.bottom, cb.bottom - this.scale.rangeExtent];
-					case "height":
-						return alignment ? [cb.bottom, cb.bottom - this.scale.rangeExtent] : [cb.top + this.scale.rangeExtent, cb.top];
-				}
-			}
-			if (AreaOrientation == Orientation.Horizontal){
-				switch (this.channel) {
-					case "width":
-					case "height": {
-						let vertices = this._vertices; // getPeers(item.firstVertex, this.scene);
-						let offset = alignment ? Math.max(...vertices.map(d => d["y"])) : Math.min(...vertices.map(d => d["y"]));
-						return alignment ? [offset, offset - this.scale.rangeExtent] : [offset + this.scale.rangeExtent, offset];
-					}
-					case "x":
-					case "y": {
-						let vertices = getPeers(area.firstVertex, this.scene);
-						let offset = Math.min(...vertices.map(d => d["x"]));
-						return [offset, offset + this.scale.rangeExtent];
-					}
-				}
-			} else if (AreaOrientation == Orientation.Vertical){
-				switch (this.channel) {	
-					case "x":
-					case "y": {
-						let vertices = getPeers(area.firstVertex, this.scene);
-						let offset = Math.max(...vertices.map(d => d["y"]));
-						return [offset, offset - this.scale.rangeExtent];
-					}
-					case "height":
-					case "width": {
-						let vertices = getPeers(area.firstVertex, this.scene);
-						let offset = alignment ? Math.min(...vertices.map(d => d["x"])) : Math.max(...vertices.map(d => d["x"]));
-						return alignment ? [offset, offset + this.scale.rangeExtent] : [offset - this.scale.rangeExtent, offset];
-					}
-				}
-			}
-		} else if (this.channel == "x") {
-			let layout = getClosestLayout(item);
-			if (layout && layout.type == LayoutType.Grid){
-				let cellBounds = layout.cellBounds;
-				let parentPeers = item.parent.parent.children;
-				let idx = parentPeers.findIndex(d => item.parent == d || item.parent.parent == d );
-				return [cellBounds[idx].left, cellBounds[idx].left + this.scale.rangeExtent];
-			} else if (item.type == "vertex" || item.type == "segment") {
-				let offset = this.scale.offset;
-				return [offset, offset + this.scale.rangeExtent];
-			} else {
-				let offset = this.scale.offset;
-				return [offset, offset + this.scale.rangeExtent];
-			}
-			
-		} else if (this.channel == "y") {
-			let layout = getClosestLayout(item);
-			if (layout && layout.type == LayoutType.Grid){
-				let cellBounds = layout.cellBounds;
-				let parentPeers = item.parent.parent.children;
-				let idx = parentPeers.findIndex(d => item.parent == d || item.parent.parent == d );
-				// if (isMark(item)) //need to take into account of mark size, cannot based in bounds bottom alone (e.g., calendar heatmap)
-				// 	return [cellBounds[idx].bottom - item.bounds.height/2, cellBounds[idx].bottom - item.bounds.height/2 - this.scale.rangeExtent];
-				// else
-					return [cellBounds[idx].bottom, cellBounds[idx].bottom - this.scale.rangeExtent];
-			} else if (item.type == "vertex" || item.type == "segment") {
-				let offset = this.scale.offset;
-				return [offset+ this.scale.rangeExtent, offset];
-			} else {
-				let offset = this.scale.offset;
-				return [offset+ this.scale.rangeExtent, offset];
-			}
-
-		} else if (this.channel == "width") {
-			let layout = getTopLevelLayout(item);
-			if (layout.type === "grid") {
-				let cellBounds = layout.cellBounds;
-				let parentPeers = item.parent.parent.children;
-				let idx = parentPeers.findIndex(d => item.parent == d || item.parent.parent == d );
-				// return [cellBounds[idx].left, cellBounds[idx].left + this.scale.rangeExtent];
-				return [cellBounds[idx].left, cellBounds[idx].right];
-			} else if (layout.type === "stack" && layout.orientation == "horizontal") {
-				return [layout.group.bounds.left, layout.group.bounds.right];
-			} else {
-				let items = getPeers(item, this.scene);
-				let offset = Math.min(...items.map(d => d.bounds.left));
-				return [offset, offset + this.scale.rangeExtent];
-			}
-		} else if (this.channel == "height") {
-			let c = getTopLevelCollection(item);
-			//let layout = getTopLevelLayout(item, "grid");
-			if (c && c.layout && ["grid", "stack"].indexOf(c.layout.type) >= 0){
-				let cellBounds = c.layout.cellBounds;
-				let parentPeers = item.parent.parent.children;
-				let idx = parentPeers.findIndex(d => item.parent === d || item.parent.parent === d );
-				//return [cellBounds[idx].bottom, cellBounds[idx].bottom - this.scale.rangeExtent];
-				//do not use rangeExtent because of possible stacking
-				return [cellBounds[idx].bottom, cellBounds[idx].bottom - cellBounds[idx].height];
-			} else {
-				let items = getPeers(item, this.scene);
-				//TODO: handle cases where items are aligned top
-				let offset = Math.max(...items.map(d => d.refBounds.bottom));
-				return [offset, offset - this.scale.rangeExtent];
-			}
-		} else if (this.channel == "radialDistance") {
-			let polygon = item.parent;
-			return [polygon.x, polygon.x + this.scale.rangeExtent];
-		} else {
-			return this.scale.range;
-		}
-	}
-
-}