372 lines
13 KiB
JavaScript
372 lines
13 KiB
JavaScript
/*
|
|
|
|
This Object object is responsible for defining the coordinate system in a TimeLine.
|
|
|
|
The scale on the X axis depends on the time.
|
|
The scale on the Y axis depends on the data that wants to be plotted. Usually we need the Max amount on that data to generate a proper scale.
|
|
|
|
*/
|
|
|
|
function newCoordinateSystem() {
|
|
let thisObject = {
|
|
min: undefined,
|
|
max: undefined,
|
|
parentMin: undefined,
|
|
parentMax: undefined,
|
|
childrenMin: undefined,
|
|
childrenMax: undefined,
|
|
maxHeight: undefined,
|
|
maxWidth: undefined,
|
|
scale: undefined,
|
|
eventHandler: undefined,
|
|
autoMinXScale: true,
|
|
autoMaxXScale: true,
|
|
autoMinYScale: true,
|
|
autoMaxYScale: true,
|
|
HORIZONTAL_MARGIN_FACTOR: 0.80,
|
|
VERTICAL_MARGIN_FACTOR: 0.90,
|
|
HORIZONTAL_MARGIN_INVERSE_FACTOR: 0.20,
|
|
VERTICAL_MARGIN_INVERSE_FACTOR: 0.10,
|
|
physics: physics,
|
|
reportParentXValue: reportParentXValue,
|
|
reportParentYValue: reportParentYValue,
|
|
reportXValue: reportXValue,
|
|
reportYValue: reportYValue,
|
|
zoomX: zoomX,
|
|
zoomY: zoomY,
|
|
recalculateScale: recalculateScale,
|
|
transformThisPoint: transformThisPoint,
|
|
transformThisPoint2: transformThisPoint2,
|
|
unInverseTransform: unInverseTransform,
|
|
inverseTransformUncappedY: inverseTransformUncappedY,
|
|
initializeX: initializeX,
|
|
initializeY: initializeY,
|
|
initialize: initialize,
|
|
finalize: finalize
|
|
}
|
|
|
|
thisObject.min = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
thisObject.max = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
thisObject.parentMin = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
thisObject.parentMax = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
thisObject.childrenMin = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
thisObject.childrenMax = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
|
|
thisObject.scale = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
|
|
thisObject.eventHandler = newEventHandler()
|
|
thisObject.eventHandler.name = 'Coordinate System'
|
|
|
|
let newXMax = -VERY_LARGE_NUMBER
|
|
let newXMin = VERY_LARGE_NUMBER
|
|
|
|
let newYMax = -VERY_LARGE_NUMBER
|
|
let newYMin = VERY_LARGE_NUMBER
|
|
|
|
let parentMinChanged = false
|
|
let parentMaxChanged = false
|
|
|
|
return thisObject
|
|
|
|
function finalize() {
|
|
thisObject.eventHandler.finalize()
|
|
thisObject.eventHandler = undefined
|
|
}
|
|
|
|
function initialize(minValue, maxValue, pMaxWidth, pMaxHeight) {
|
|
/* Defines the min and max value of rate that we are going to transport to the available screen at the center position. */
|
|
thisObject.min.x = minValue.x
|
|
thisObject.max.x = maxValue.x
|
|
|
|
thisObject.min.y = minValue.y
|
|
thisObject.max.y = maxValue.y
|
|
|
|
thisObject.maxWidth = pMaxWidth
|
|
thisObject.maxHeight = pMaxHeight
|
|
|
|
recalculateScale()
|
|
}
|
|
|
|
function reportXValue(value) {
|
|
if (thisObject.autoMinXScale === true) {
|
|
if (value < newXMin && value !== 0) {
|
|
newXMin = value
|
|
}
|
|
}
|
|
if (thisObject.autoMaxXScale === true) {
|
|
if (value > newXMax && value !== 0) {
|
|
newXMax = value
|
|
}
|
|
}
|
|
}
|
|
|
|
function reportYValue(value) {
|
|
if (thisObject.autoMinYScale === true) {
|
|
if (value < newYMin) {
|
|
newYMin = value
|
|
}
|
|
}
|
|
if (thisObject.autoMaxYScale === true) {
|
|
if (value > newYMax) {
|
|
newYMax = value
|
|
}
|
|
}
|
|
}
|
|
|
|
function reportParentXValue(min, max) {
|
|
if (thisObject.autoMinXScale === true) {
|
|
if (thisObject.parentMin.x !== min) {
|
|
thisObject.parentMin.x = min
|
|
}
|
|
}
|
|
if (thisObject.autoMaxXScale === true) {
|
|
if (thisObject.parentMax.x !== max) {
|
|
thisObject.parentMax.x = max
|
|
}
|
|
}
|
|
}
|
|
|
|
function reportParentYValue(min, max) {
|
|
if (thisObject.autoMinYScale === true) {
|
|
if (thisObject.parentMin.y !== min) {
|
|
thisObject.parentMin.y = min
|
|
}
|
|
}
|
|
if (thisObject.autoMaxYScale === true) {
|
|
if (thisObject.parentMax.y !== max) {
|
|
thisObject.parentMax.y = max
|
|
}
|
|
}
|
|
}
|
|
|
|
function physics() {
|
|
let mustRecalculate = false
|
|
|
|
if ((thisObject.autoMinXScale === true || thisObject.autoMaxXScale === true)) {
|
|
if (thisObject.autoMaxXScale === true && thisObject.childrenMax.x !== newXMax && newXMax !== -VERY_LARGE_NUMBER) {
|
|
thisObject.childrenMax.x = newXMax
|
|
}
|
|
|
|
if (thisObject.autoMaxXScale === true) {
|
|
newXMax = -VERY_LARGE_NUMBER
|
|
}
|
|
|
|
if (thisObject.autoMinXScale === true && thisObject.childrenMin.x !== newXMin && newXMin !== VERY_LARGE_NUMBER) {
|
|
thisObject.childrenMin.x = newXMin
|
|
newXMin = VERY_LARGE_NUMBER
|
|
}
|
|
|
|
if (thisObject.autoMinXScale === true) {
|
|
newXMin = VERY_LARGE_NUMBER
|
|
}
|
|
}
|
|
|
|
if ((thisObject.autoMinYScale === true || thisObject.autoMaxYScale === true)) {
|
|
if (thisObject.autoMaxYScale === true && thisObject.childrenMax.y !== newYMax && newYMax !== -VERY_LARGE_NUMBER) {
|
|
thisObject.childrenMax.y = newYMax
|
|
}
|
|
|
|
if (thisObject.autoMaxYScale === true) {
|
|
newYMax = -VERY_LARGE_NUMBER
|
|
}
|
|
|
|
if (thisObject.autoMinYScale === true && thisObject.childrenMin.y !== newYMin && newYMin !== VERY_LARGE_NUMBER) {
|
|
thisObject.childrenMin.y = newYMin
|
|
newYMin = VERY_LARGE_NUMBER
|
|
}
|
|
|
|
if (thisObject.autoMinYScale === true) {
|
|
newYMin = VERY_LARGE_NUMBER
|
|
}
|
|
}
|
|
|
|
/* Here we will see if any of the children or parent values modify the current status quo */
|
|
/* Min */
|
|
let minX = Math.min(thisObject.childrenMin.x, thisObject.parentMin.x)
|
|
let minY = Math.min(thisObject.childrenMin.y, thisObject.parentMin.y)
|
|
let maxX = Math.max(thisObject.childrenMax.x, thisObject.parentMax.x)
|
|
let maxY = Math.max(thisObject.childrenMax.y, thisObject.parentMax.y)
|
|
|
|
if (thisObject.parentMin.x === 0) {
|
|
minX = thisObject.childrenMin.x
|
|
}
|
|
|
|
if (thisObject.parentMin.y === 0) {
|
|
minY = thisObject.childrenMin.y
|
|
}
|
|
|
|
if (thisObject.parentMax.x === 0) {
|
|
maxX = thisObject.childrenMax.x
|
|
}
|
|
|
|
if (thisObject.parentMax.y === 0) {
|
|
maxY = thisObject.childrenMax.y
|
|
}
|
|
|
|
if (minX !== 0 && thisObject.min.x !== minX && thisObject.autoMinXScale === true) {
|
|
thisObject.min.x = minX
|
|
mustRecalculate = true
|
|
}
|
|
|
|
if (minY !== 0 && thisObject.min.y !== minY && thisObject.autoMinYScale === true) {
|
|
thisObject.min.y = minY
|
|
mustRecalculate = true
|
|
}
|
|
|
|
if (maxX !== 0 && thisObject.max.x !== maxX && thisObject.autoMaxXScale === true) {
|
|
thisObject.max.x = maxX
|
|
mustRecalculate = true
|
|
}
|
|
|
|
if (maxY !== 0 && thisObject.max.y !== maxY && thisObject.autoMaxYScale === true) {
|
|
thisObject.max.y = maxY
|
|
mustRecalculate = true
|
|
}
|
|
|
|
if (mustRecalculate === true) {
|
|
recalculateScale()
|
|
}
|
|
}
|
|
|
|
function recalculateScale(event) {
|
|
thisObject.scale.x = thisObject.maxWidth * thisObject.HORIZONTAL_MARGIN_FACTOR / (thisObject.max.x - thisObject.min.x)
|
|
thisObject.scale.y = thisObject.maxHeight * thisObject.VERTICAL_MARGIN_FACTOR / (thisObject.max.y - thisObject.min.y)
|
|
|
|
thisObject.eventHandler.raiseEvent('Scale Changed', event)
|
|
}
|
|
|
|
function zoomX(factor, mousePosition, container) {
|
|
let mouseAtCointainer = unTransformThisPoint(mousePosition, container)
|
|
let leftDistance = mouseAtCointainer.x
|
|
let rightDistance = container.frame.width - mouseAtCointainer.x
|
|
let diff = thisObject.max.x - thisObject.min.x
|
|
let min = thisObject.min.x + diff * factor * leftDistance / (container.frame.width / 2)
|
|
let max = thisObject.max.x - diff * factor * rightDistance / (container.frame.width / 2)
|
|
|
|
if (min < max) {
|
|
let mustRecalculate = false
|
|
if (thisObject.autoMinXScale === false) {
|
|
thisObject.min.x = min
|
|
mustRecalculate = true
|
|
}
|
|
if (thisObject.autoMaxXScale === false) {
|
|
thisObject.max.x = max
|
|
mustRecalculate = true
|
|
}
|
|
if (mustRecalculate === true) {
|
|
thisObject.recalculateScale()
|
|
}
|
|
}
|
|
}
|
|
|
|
function zoomY(factor, mousePosition, container) {
|
|
let mouseAtCointainer = unTransformThisPoint(mousePosition, container)
|
|
let topDistance = mouseAtCointainer.y
|
|
let bottomDistance = container.frame.height - mouseAtCointainer.y
|
|
let diff = thisObject.max.y - thisObject.min.y
|
|
let min = thisObject.min.y + diff * factor * bottomDistance / (container.frame.height / 2)
|
|
let max = thisObject.max.y - diff * factor * topDistance / (container.frame.height / 2)
|
|
|
|
if (min < max) {
|
|
let mustRecalculate = false
|
|
if (thisObject.autoMinYScale === false) {
|
|
thisObject.min.y = min
|
|
mustRecalculate = true
|
|
}
|
|
if (thisObject.autoMaxYScale === false) {
|
|
thisObject.max.y = max
|
|
mustRecalculate = true
|
|
}
|
|
if (mustRecalculate === true) {
|
|
thisObject.recalculateScale()
|
|
}
|
|
}
|
|
}
|
|
|
|
function initializeX(minValue, maxValue, maxWidth) {
|
|
thisObject.min.x = minValue.x // * 0.999; // 0.1% less
|
|
thisObject.max.x = maxValue.x // * 1.001; // 0.1% more
|
|
|
|
thisObject.scale.x = thisObject.maxWidth / (thisObject.max.x - thisObject.min.x)
|
|
}
|
|
|
|
function initializeY(minValue, maxValue, pMaxHeight) {
|
|
thisObject.min.y = minValue.y // * 0.999; // 0.1% less
|
|
thisObject.max.y = maxValue.y // * 1.001; // 0.1% more
|
|
|
|
thisObject.scale.y = pMaxHeight / (thisObject.max.y - thisObject.min.y)
|
|
|
|
thisObject.maxHeight = pMaxHeight
|
|
}
|
|
|
|
function transformThisPoint(point) {
|
|
/*
|
|
|
|
This is the straigh fordward transformation this object provides. The input is a point on the data set that wants to be plotted in a timeline.
|
|
The x value of the point must be a datetime.valueOf() and is going to be transformed into an x value on the coordinate system of the timeline.
|
|
The y value should be a value in the dataset at that moment in time. Depending on how this coordinate system was initialized then are the
|
|
possible values y can have. For sure it must be in the range between the min and max y declared at initialization. The y value has a special
|
|
treatment since the browser canvas object used, has a zero y value at the top, while the timeline we use has a zero y value at the botton,
|
|
for that reason y is flipped.
|
|
|
|
Besides this, what we do is to multiply by the scale, which in turn is calculated at initialization time depending on the values provided.
|
|
|
|
*/
|
|
|
|
point = {
|
|
x: (point.x - thisObject.min.x) * thisObject.scale.x + thisObject.maxWidth * thisObject.HORIZONTAL_MARGIN_INVERSE_FACTOR / 2,
|
|
y: thisObject.maxHeight - (point.y - thisObject.min.y) * thisObject.scale.y - thisObject.maxHeight * thisObject.VERTICAL_MARGIN_INVERSE_FACTOR / 2
|
|
}
|
|
|
|
return point
|
|
}
|
|
|
|
function transformThisPoint2(point) {
|
|
point = {
|
|
x: (point.x - thisObject.min.x) * thisObject.scale.x + thisObject.maxWidth * thisObject.HORIZONTAL_MARGIN_INVERSE_FACTOR / 2,
|
|
y: (thisObject.maxHeight - point.y - thisObject.min.y) * thisObject.scale.y - thisObject.maxHeight * thisObject.VERTICAL_MARGIN_INVERSE_FACTOR / 2
|
|
}
|
|
|
|
return point
|
|
}
|
|
|
|
function unInverseTransform(point, inverseY) {
|
|
point = {
|
|
x: ((point.x - thisObject.maxWidth * thisObject.HORIZONTAL_MARGIN_INVERSE_FACTOR / 2) / thisObject.scale.x) + thisObject.min.x,
|
|
y: (inverseY * thisObject.VERTICAL_MARGIN_FACTOR - point.y + thisObject.maxHeight * thisObject.VERTICAL_MARGIN_INVERSE_FACTOR / 2) / thisObject.scale.y + thisObject.min.y
|
|
}
|
|
|
|
return point
|
|
}
|
|
|
|
function inverseTransformUncappedY(point, inverseY) {
|
|
point = {
|
|
x: (point.x - thisObject.min.x) * thisObject.scale.x + thisObject.maxWidth * thisObject.HORIZONTAL_MARGIN_INVERSE_FACTOR / 2,
|
|
y: (inverseY * thisObject.VERTICAL_MARGIN_FACTOR - point.y) * thisObject.scale.y - thisObject.maxHeight * thisObject.VERTICAL_MARGIN_INVERSE_FACTOR / 2
|
|
}
|
|
|
|
return point
|
|
}
|
|
}
|