var _____WB$wombat$assign$function_____ = function(name) {return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name)) || self[name]; };
if (!self.__WB_pmw) { self.__WB_pmw = function(obj) { this.__WB_source = obj; return this; } }
{
let window = _____WB$wombat$assign$function_____("window");
let self = _____WB$wombat$assign$function_____("self");
let document = _____WB$wombat$assign$function_____("document");
let location = _____WB$wombat$assign$function_____("location");
let top = _____WB$wombat$assign$function_____("top");
let parent = _____WB$wombat$assign$function_____("parent");
let frames = _____WB$wombat$assign$function_____("frames");
let opener = _____WB$wombat$assign$function_____("opener");
function ChartHitRectangle(left, top, right, bottom) {
this.left = left;
this.top = top;
this.right = right;
this.bottom = bottom;
}
ChartHitRectangle.prototype = {
IsVisible: function(x, y) {
return (x >= this.left) && (x < this.right) && (y >= this.top) && (y < this.bottom);
}
}
ChartHitRectangle.prototype.constructor = ChartHitRectangle;
function ChartHitEmpty() {
}
ChartHitEmpty.prototype = {
IsVisible: function(x, y) {
return false;
}
}
ChartHitEmpty.prototype.constructor = ChartHitEmpty;
function ChartHitExpression(leftOperand, rightOperand) {
if(ChartHitExpression.AsProrotype)
return delete ChartHitExpression.AsProrotype;
this.leftOperand = leftOperand;
this.rightOperand = rightOperand;
}
ChartHitExpression.prototype = {
IsVisible: function(x, y) {
throw "ChartHitExpression abstract error";
}
}
ChartHitExpression.prototype.constructor = ChartHitExpression;
function ChartHitUnion(leftOperand, rightOperand) {
ChartHitExpression.call(this, leftOperand, rightOperand);
}
ChartHitExpression.AsPrototype = true;
ChartHitUnion.prototype = new ChartHitExpression();
ChartHitUnion.prototype.constructor = ChartHitUnion;
ChartHitUnion.prototype.IsVisible = function(x, y) {
return this.leftOperand.IsVisible(x, y) || this.rightOperand.IsVisible(x, y);
}
function ChartHitIntersection(leftOperand, rightOperand) {
ChartHitExpression.call(this, leftOperand, rightOperand);
}
ChartHitExpression.AsPrototype = true;
ChartHitIntersection.prototype = new ChartHitExpression();
ChartHitIntersection.prototype.constructor = ChartHitIntersection;
ChartHitIntersection.prototype.IsVisible = function(x, y) {
return this.leftOperand.IsVisible(x, y) && this.rightOperand.IsVisible(x, y);
}
function ChartHitExclusion(leftOperand, rightOperand) {
ChartHitExpression.call(this, leftOperand, rightOperand);
}
ChartHitExpression.AsPrototype = true;
ChartHitExclusion.prototype = new ChartHitExpression();
ChartHitExclusion.prototype.constructor = ChartHitExclusion;
ChartHitExclusion.prototype.IsVisible = function(x, y) {
return this.leftOperand.IsVisible(x, y) && !this.rightOperand.IsVisible(x, y);
}
function ChartHitXor(leftOperand, rightOperand) {
ChartHitExpression.call(this, leftOperand, rightOperand);
}
ChartHitExpression.AsPrototype = true;
ChartHitXor.prototype = new ChartHitExpression();
ChartHitXor.prototype.constructor = ChartHitXor;
ChartHitXor.prototype.IsVisible = function(x, y) {
return this.leftOperand.IsVisible(x, y) ^ this.rightOperand.IsVisible(x, y);
}
function ChartHitPath(lineSegments, alternate) {
this.lineSegments = lineSegments;
this.alternate = alternate;
}
ChartHitPath.prototype = {
IsVisible: function(x, y) {
if(this.lineSegments.length == 0)
return false;
var isVisible = this.IsVisibleInternal(x - 0.01, y);
if(!isVisible)
isVisible = this.IsVisibleInternal(x + 0.01, y);
return isVisible;
},
IsVisibleInternal: function(x, y) {
var filteredLineSegments = this.FilterLineSegments(x, y);
if(filteredLineSegments.length == 0)
return false;
var xIntersections = new ChartXIntersections(filteredLineSegments, x);
var indicator = this.CalcIndicator(filteredLineSegments, xIntersections, y);
return this.alternate ? (indicator % 2) != 0 : indicator != 0;
},
FilterLineSegments: function(x, y) {
var filteredLineSegments = new Array();
for(var i = 0; i < this.lineSegments.length; i++) {
var lineSegment = this.lineSegments[i];
if(this.ShouldFilterLineSegmentByX(lineSegment, x))
continue;
if(this.ShouldFilterLineSegmentByY(lineSegment, y))
continue;
filteredLineSegments.push(lineSegment);
}
return filteredLineSegments;
},
ShouldFilterLineSegmentByX: function(lineSegment, x) {
return ((lineSegment.startX < x) && (lineSegment.finishX < x)) ||
((lineSegment.startX > x) && (lineSegment.finishX > x));
},
ShouldFilterLineSegmentByY: function(lineSegment, y) {
return (lineSegment.startY < y) && (lineSegment.finishY < y);
},
CalcIndicator: function(lineSegments, xIntersections, y) {
var indicator = 0;
for(var i = 0; i < xIntersections.intersections.length; i++) {
if(xIntersections.intersections[i] < y)
continue;
if(lineSegments[i].LeftToRight())
indicator++;
else if(lineSegments[i].RightToLeft())
indicator--;
else
throw ChartLineSegment.err;
}
return indicator;
}
}
ChartHitPath.prototype.constructor = ChartHitPath;
function ChartLineSegment(startX, startY, finishX, finishY) {
this.startX = startX;
this.startY = startY;
this.finishX = finishX;
this.finishY = finishY;
}
ChartLineSegment.err = "Invalid line segment";
ChartLineSegment.prototype = {
LeftToRight : function() {
return this.startX < this.finishX;
},
RightToLeft : function() {
return this.startX > this.finishX;
}
}
ChartLineSegment.prototype.constructor = ChartLineSegment;
function ChartXIntersections(lineSegments, x) {
this.intersections = new Array(lineSegments.length);
for(var i = 0; i < lineSegments.length; i++)
this.intersections[i] = this.CalcIntersection(lineSegments[i], x);
}
ChartXIntersections.prototype = {
CalcIntersection: function(lineSegment, x) {
var delta = lineSegment.finishX - lineSegment.startX;
if(delta == 0)
throw ChartLineSegment.err;
var k = (lineSegment.finishY - lineSegment.startY) / delta;
var b = (lineSegment.startY * lineSegment.finishX - lineSegment.finishY * lineSegment.startX) / delta;
return k * x + b;
}
}
ChartXIntersections.prototype.constructor = ChartXIntersections;
function ChartHitTestController(hitInfo) {
this.objects = new Array();
this.additionalObjects = new Array();
var hitInfoLoader = new ChartHitInfoLoader(hitInfo);
this.regions = hitInfoLoader.regions;
}
ChartHitTestController.prototype = {
HitTest: function(x, y) {
var hitRegions = this.CreateHitRegions(x, y);
return this.CreateHitObjects(hitRegions);
},
CreateHitRegions: function(x, y) {
var hitRegions = new Array();
for(var i = 0; i < this.regions.length; i++)
if(this.regions[i].IsVisible(x, y))
hitRegions.push(this.regions[i]);
return hitRegions;
},
CreateHitObjects: function(hitRegions) {
var hitObjects = new Array();
for(var i = 0; i < hitRegions.length; i++) {
var hitRegion = hitRegions[i];
hitObjects.push(this.CreateHitObject(hitRegion));
}
return hitObjects;
},
CreateHitObject: function(hitRegion) {
var hitObject = this.objects[hitRegion.id];
var additionalHitObject =
hitRegion.additionalId != -1 ?
this.additionalObjects[hitRegion.additionalId] :
null;
if (_aspxIsExists(hitRegion.toolTipPoint) && additionalHitObject != null)
additionalHitObject.toolTipPoint = hitRegion.toolTipPoint;
return new ASPxClientHitObject(hitObject, additionalHitObject);
}
}
ChartHitTestController.prototype.constructor = ChartHitTestController;
function ChartHitRegion(primitive, id, additionalId, toolTipPoint) {
this.primitive = primitive;
this.id = id;
this.additionalId = additionalId;
this.toolTipPoint = toolTipPoint;
}
ChartHitRegion.prototype = {
IsVisible: function(x, y) {
return this.primitive.IsVisible(x, y);
}
}
ChartHitRegion.prototype.constructor = ChartHitRegion;
function ChartHitInfoLoader(hitInfo) {
this.regions = new Array();
this.LoadHitInfo(hitInfo);
}
ChartHitInfoLoader.errPrefix = "ChartHitTestController loading error: ";
ChartHitInfoLoader.errRegionType = ChartHitTestController.errPrefix + "Invalid hit region type";
ChartHitInfoLoader.errRegionFormat = ChartHitTestController.errPrefix + "Invalid hit region format";
ChartHitInfoLoader.prototype = {
LoadHitInfo: function(hitInfo) {
for(var i = 0; i < hitInfo.length; i++)
this.LoadHitRegion(hitInfo[i]);
},
LoadHitRegion: function(interimHitRegion) {
var id = interimHitRegion.hi;
var additionalId = _aspxIsExists(interimHitRegion.hia) ? interimHitRegion.hia: -1;
var primitive = this.LoadPrimitive(interimHitRegion.r);
var toolTipPoint = interimHitRegion.ttp;
this.regions.unshift(new ChartHitRegion(primitive, id, additionalId, toolTipPoint));
},
LoadPrimitive: function(interimPrimitive) {
if(interimPrimitive.t == "R")
return this.LoadRectangle(interimPrimitive);
else if(interimPrimitive.t == "O")
return new ChartHitEmpty();
else if(interimPrimitive.t == "U")
return this.LoadUnion(interimPrimitive);
else if(interimPrimitive.t == "I")
return this.LoadIntersection(interimPrimitive);
else if(interimPrimitive.t == "E")
return this.LoadExclusion(interimPrimitive);
else if(interimPrimitive.t == "X")
return this.LoadXor(interimPrimitive);
else if(interimPrimitive.t == "P")
return this.LoadPath(interimPrimitive);
throw ChartHitInfoLoader.errRegionType;
},
LoadRectangle: function(interimRectangle) {
if(interimRectangle.r.length != 4)
throw ChartHitInfoLoader.errRegionFormat;
return new ChartHitRectangle(interimRectangle.r[0], interimRectangle.r[1], interimRectangle.r[2], interimRectangle.r[3]);
},
LoadUnion: function(interimExpression) {
var leftOperand = this.LoadPrimitive(interimExpression.l);
var rightOperand = this.LoadPrimitive(interimExpression.r);
return new ChartHitUnion(leftOperand, rightOperand);
},
LoadIntersection: function(interimExpression) {
var leftOperand = this.LoadPrimitive(interimExpression.l);
var rightOperand = this.LoadPrimitive(interimExpression.r);
return new ChartHitIntersection(leftOperand, rightOperand);
},
LoadExclusion: function(interimExpression) {
var leftOperand = this.LoadPrimitive(interimExpression.l);
var rightOperand = this.LoadPrimitive(interimExpression.r);
return new ChartHitExclusion(leftOperand, rightOperand);
},
LoadXor: function(interimExpression) {
var leftOperand = this.LoadPrimitive(interimExpression.l);
var rightOperand = this.LoadPrimitive(interimExpression.r);
return new ChartHitXor(leftOperand, rightOperand);
},
LoadPath: function(interimPath) {
var lineSegments = new Array();
var points = new Array();
var bezierPoints = new Array();
var indexInStartArray = 0;
var indexInBezierArray = 0;
for(var pointIndex = 0; pointIndex < interimPath.p.length; pointIndex++) {
if(this.IsStartPoint(interimPath, pointIndex, indexInStartArray)) {
indexInStartArray++;
this.UpdateLineSegments(lineSegments, points);
points.length = 0;
}
else if(this.IsBezierPoint(interimPath, pointIndex, indexInBezierArray)) {
indexInBezierArray++;
if(bezierPoints.length == 0)
bezierPoints.push(interimPath.p[pointIndex - 1]);
bezierPoints.push(interimPath.p[pointIndex]);
if(bezierPoints.length == 4) {
this.CalcBezierApproximation(
bezierPoints[0][0], bezierPoints[0][1],
bezierPoints[1][0], bezierPoints[1][1],
bezierPoints[2][0], bezierPoints[2][1],
bezierPoints[3][0], bezierPoints[3][1], points);
bezierPoints.length = 0;
}
continue;
}
points.push(interimPath.p[pointIndex]);
}
this.UpdateLineSegments(lineSegments, points);
return new ChartHitPath(lineSegments, interimPath.a);
},
UpdateLineSegments: function(lineSegments, points) {
if(points.length < 2)
return;
for(var i = 0; i < points.length - 1; i++)
lineSegments.push(new ChartLineSegment(
points[i][0],
points[i][1],
points[i + 1][0],
points[i + 1][1]));
lineSegments.push(new ChartLineSegment(
points[points.length - 1][0],
points[points.length - 1][1],
points[0][0],
points[0][1]));
},
CreatePoint: function(x, y) {
return [x, y];
},
IsStartPoint: function(interimPath, pointIndex, indexInStartArray) {
return (indexInStartArray < interimPath.s.length) && (interimPath.s[indexInStartArray] == pointIndex);
},
IsBezierPoint: function(interimPath, pointIndex, indexInBezierArray) {
return (indexInBezierArray < interimPath.b.length) && (interimPath.b[indexInBezierArray] == pointIndex);
},
CalcBezierApproximation: function(x1, y1, x2, y2, x3, y3, x4, y4, points) {
var dx1 = x2 - x1;
var dy1 = y2 - y1;
var dx2 = x3 - x2;
var dy2 = y3 - y2;
var dx3 = x4 - x3;
var dy3 = y4 - y3;
var length = Math.sqrt(dx1 * dx1 + dy1 * dy1) + Math.sqrt(dx2 * dx2 + dy2 * dy2) + Math.sqrt(dx3 * dx3 + dy3 * dy3);
var stepCount = Math.round(length * 0.25);
var step = 1 / (stepCount + 1);
var step2 = step * step;
var step3 = step * step * step;
var step13 = step * 3;
var step23 = step2 * 3;
var step26 = step2 * 6;
var step36 = step3 * 6;
var tempX1 = x1 - x2 * 2 + x3;
var tempY1 = y1 - y2 * 2 + y3;
var tempX2 = (x2 - x3) * 3 - x1 + x4;
var tempY2 = (y2 - y3) * 3 - y1 + y4;
var dx = (x2 - x1) * step13 + tempX1 * step23 + tempX2 * step3;
var dy = (y2 - y1) * step13 + tempY1 * step23 + tempY2 * step3;
var ddx = tempX1 * step26 + tempX2 * step36;
var ddy = tempY1 * step26 + tempY2 * step36;
var dddx = tempX2 * step36;
var dddy = tempY2 * step36;
var x = x1;
var y = y1;
for(var i = 0; i < stepCount; i++) {
x += dx;
y += dy;
points.push(this.CreatePoint(x, y));
dx += ddx;
dy += ddy;
ddx += dddx;
ddy += dddy;
}
points.push(this.CreatePoint(x4, y4));
}
}
ChartHitInfoLoader.prototype.constructor = ChartHitInfoLoader;
}
/*
playback timings (ms):
CDXLines.iter: 19.325 (3)
exclusion.robots: 0.247
captures_list: 74.837
RedisCDXSource: 0.72
esindex: 0.015
load_resource: 61.969
PetaboxLoader3.datanode: 70.378 (4)
PetaboxLoader3.resolve: 23.004
LoadShardBlock: 50.28 (3)
exclusion.robots.policy: 0.23
*/