1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
|
import { PIXIPoint } from "./MathUtil";
import { VisualBinRange } from "../model/binRanges/VisualBinRange";
import { Bin, DoubleValueAggregateResult, AggregateKey } from "../model/idea/idea";
import { ModelHelpers } from "../model/ModelHelpers";
import { observable, action, computed } from "mobx";
export class SizeConverter {
public DataMins: Array<number> = new Array<number>(2);
public DataMaxs: Array<number> = new Array<number>(2);
public DataRanges: Array<number> = new Array<number>(2);
public MaxLabelSizes: Array<PIXIPoint> = new Array<PIXIPoint>(2);
public RenderDimension: number = 300;
@observable _leftOffset: number = 40;
@observable _rightOffset: number = 20;
@observable _topOffset: number = 20;
@observable _bottomOffset: number = 45;
@observable _labelAngle: number = 0;
@observable _isSmall: boolean = false;
@observable public Initialized = 0;
@action public SetIsSmall(isSmall: boolean) { this._isSmall = isSmall; }
@action public SetLabelAngle(angle: number) { this._labelAngle = angle; }
@computed public get IsSmall() { return this._isSmall; }
@computed public get LabelAngle() { return this._labelAngle; }
@computed public get LeftOffset() { return this.IsSmall ? 5 : this._leftOffset; }
@computed public get RightOffset() { return this.IsSmall ? 5 : !this._labelAngle ? this._bottomOffset : Math.max(this._rightOffset, Math.cos(this._labelAngle) * (this.MaxLabelSizes[0].x + 18)); }
@computed public get TopOffset() { return this.IsSmall ? 5 : this._topOffset; }
@computed public get BottomOffset() { return this.IsSmall ? 25 : !this._labelAngle ? this._bottomOffset : Math.max(this._bottomOffset, Math.sin(this._labelAngle) * (this.MaxLabelSizes[0].x + 18)) + 18; }
public SetVisualBinRanges(visualBinRanges: Array<VisualBinRange>) {
this.Initialized++;
var xLabels = visualBinRanges[0].GetLabels();
var yLabels = visualBinRanges[1].GetLabels();
var xLabelStrings = xLabels.map(l => l.label!).sort(function (a, b) { return b.length - a.length; });
var yLabelStrings = yLabels.map(l => l.label!).sort(function (a, b) { return b.length - a.length; });
var metricsX = { width: 75 }; // RenderUtils.MeasureText(FontStyles.Default.fontFamily.toString(), 12, // FontStyles.AxisLabel.fontSize as number,
//xLabelStrings[0]!.slice(0, 20)) // StyleConstants.MAX_CHAR_FOR_HISTOGRAM_LABELS));
var metricsY = { width: 22 }; // RenderUtils.MeasureText(FontStyles.Default.fontFamily.toString(), 12, // FontStyles.AxisLabel.fontSize as number,
// yLabelStrings[0]!.slice(0, 20)); // StyleConstants.MAX_CHAR_FOR_HISTOGRAM_LABELS));
this.MaxLabelSizes[0] = new PIXIPoint(metricsX.width, 12);// FontStyles.AxisLabel.fontSize as number);
this.MaxLabelSizes[1] = new PIXIPoint(metricsY.width, 12); // FontStyles.AxisLabel.fontSize as number);
this._leftOffset = Math.max(10, metricsY.width + 10 + 20);
this.DataMins[0] = xLabels.map(l => l.minValue!).reduce((m, c) => Math.min(m, c), Number.MAX_VALUE);
this.DataMins[1] = yLabels.map(l => l.minValue!).reduce((m, c) => Math.min(m, c), Number.MAX_VALUE);
this.DataMaxs[0] = xLabels.map(l => l.maxValue!).reduce((m, c) => Math.max(m, c), Number.MIN_VALUE);
this.DataMaxs[1] = yLabels.map(l => l.maxValue!).reduce((m, c) => Math.max(m, c), Number.MIN_VALUE);
this.DataRanges[0] = this.DataMaxs[0] - this.DataMins[0];
this.DataRanges[1] = this.DataMaxs[1] - this.DataMins[1];
}
public DataToScreenNormalizedRange(dataValue: number, normalization: number, axis: number, binBrushMaxAxis: number) {
var value = normalization !== 1 - axis || binBrushMaxAxis === 0 ? dataValue : (dataValue - 0) / (binBrushMaxAxis - 0) * this.DataRanges[axis];
var from = this.DataToScreenCoord(Math.min(0, value), axis);
var to = this.DataToScreenCoord(Math.max(0, value), axis);
return [from, value, to];
}
public DataToScreenPointRange(axis: number, bin: Bin, aggregateKey: AggregateKey) {
var value = ModelHelpers.GetAggregateResult(bin, aggregateKey) as DoubleValueAggregateResult;
if (value && value.hasResult) {
return [this.DataToScreenCoord(value.result!, axis) - 5,
this.DataToScreenCoord(value.result!, axis) + 5];
}
return [undefined, undefined];
}
public DataToScreenXAxisRange(visualBinRanges: VisualBinRange[], index: number, bin: Bin) {
var value = visualBinRanges[0].GetValueFromIndex(bin.binIndex!.indices![index]);
return [this.DataToScreenX(value), this.DataToScreenX(visualBinRanges[index].AddStep(value))];
}
public DataToScreenYAxisRange(visualBinRanges: VisualBinRange[], index: number, bin: Bin) {
var value = visualBinRanges[1].GetValueFromIndex(bin.binIndex!.indices![index]);
return [this.DataToScreenY(value), this.DataToScreenY(visualBinRanges[index].AddStep(value))];
}
public DataToScreenX(x: number): number {
return ((x - this.DataMins[0]) / this.DataRanges[0]) * this.RenderDimension;
}
public DataToScreenY(y: number, flip: boolean = true) {
var retY = ((y - this.DataMins[1]) / this.DataRanges[1]) * this.RenderDimension;
return flip ? (this.RenderDimension) - retY : retY;
}
public DataToScreenCoord(v: number, axis: number) {
if (axis === 0) {
return this.DataToScreenX(v);
}
return this.DataToScreenY(v);
}
public DataToScreenRange(minVal: number, maxVal: number, axis: number) {
let xFrom = this.DataToScreenX(axis === 0 ? minVal : this.DataMins[0]);
let xTo = this.DataToScreenX(axis === 0 ? maxVal : this.DataMaxs[0]);
let yFrom = this.DataToScreenY(axis === 1 ? minVal : this.DataMins[1]);
let yTo = this.DataToScreenY(axis === 1 ? maxVal : this.DataMaxs[1]);
return { xFrom, yFrom, xTo, yTo };
}
}
|
