public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; Func <ChartAlertValue, Point> getBarPoint = v => v.ValueType != ChartAlertValueType.StaticValue ? new Point(chartControl.GetXByTime(v.Time), chartScale.GetYByValue(v.Value)) : new Point(0, 0); Predicate <ChartAlertValue> predicate = v => { bool isInside = IsPointInsideTimeCycles(chartPanel, getBarPoint(v)); return(condition == Condition.CrossInside ? isInside : !isInside); }; return(MathHelper.DidPredicateCross(values, predicate)); }
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; double barX = chartControl.GetXByTime(values[0].Time); double barY = chartScale.GetYByValue(values[0].Value); Point startPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale); Point endPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale); Point barPoint = new Point(barX, barY); if (arcGeometry == null || arcGeometry.IsDisposed) { UpdateArcGeometry(chartControl, chartPanel, chartScale); } // Bars have not yet reached edge of drawing tool if (barX < Math.Min(startPoint.X, endPoint.X)) { return(false); } // Do two things, make sure the point is on the right side of the line (the side arc is sweeped into), // and if it is, then check if it is in arc geo MathHelper.PointLineLocation ptLineLocation = MathHelper.GetPointLineLocation(startPoint, endPoint, barPoint); // If its not right/above , its past the line the arc sweeps on, so ignore if (ptLineLocation != MathHelper.PointLineLocation.RightOrBelow) { return(false); } // Our only conditions are cross inside/outside Predicate <ChartAlertValue> arcPredicate = v => { if (v.Time == Core.Globals.MinDate || v.Time == Core.Globals.MaxDate) { return(false); } if (v.Value == double.MinValue) { return(false); } double bX = chartControl.GetXByTime(v.Time); double bY = chartScale.GetYByValue(v.Value); Point bp = new Point(bX, bY); bool isInGeo = arcGeometry.FillContainsPoint(bp.ToVector2()); return(condition == Condition.CrossInside ? isInGeo : !isInGeo); }; return(MathHelper.DidPredicateCross(values, arcPredicate)); }
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { double minPrice = Anchors.Min(a => a.Price); double maxPrice = Anchors.Max(a => a.Price); DateTime minTime = Anchors.Min(a => a.Time); DateTime maxTime = Anchors.Max(a => a.Time); // note, time region higlight x will always be a cross from moving linearly. until someone builds a time machine anyway // no need for lookback/cross check so just check first (most recent) value if (Mode == RegionHighlightMode.Time) { DateTime vt = values[0].Time; return(condition == Condition.CrossInside ? vt > minTime && vt <= maxTime : vt > minTime && vt < maxTime); } Predicate <ChartAlertValue> predicate = v => { bool isInside = Mode == RegionHighlightMode.Time ? v.Time >= minTime && v.Time <= maxTime : v.Value >= minPrice && v.Value <= maxPrice; return(condition == Condition.CrossInside ? isInside : !isInside); }; return(MathHelper.DidPredicateCross(values, predicate)); }
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { PathToolSegment segAnchors = conditionItem.Tag as PathToolSegment; if (segAnchors == null) { return(false); } ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; Point lineStartPoint = segAnchors.StartAnchor.GetPoint(chartControl, chartPanel, chartScale); Point lineEndPoint = segAnchors.EndAnchor.GetPoint(chartControl, chartPanel, chartScale); double minLineX = double.MaxValue; double maxLineX = double.MinValue; foreach (Point point in new[] { lineStartPoint, lineEndPoint }) { minLineX = Math.Min(minLineX, point.X); maxLineX = Math.Max(maxLineX, point.X); } // first thing, if our smallest x is greater than most recent bar, we have nothing to do yet. // do not try to check Y because lines could cross through stuff double firstBarX = values[0].ValueType == ChartAlertValueType.StaticValue ? minLineX : chartControl.GetXByTime(values[0].Time); double firstBarY = chartScale.GetYByValue(values[0].Value); // dont have to take extension into account as its already handled in min/max line x // bars completely passed our line if (maxLineX < firstBarX) { return(false); } // bars not yet to our line if (minLineX > firstBarX) { return(false); } // NOTE: normalize line points so the leftmost is passed first. Otherwise, our vector // math could end up having the line normal vector being backwards if user drew it backwards. // but we dont care the order of anchors, we want 'up' to mean 'up'! Point leftPoint = lineStartPoint.X < lineEndPoint.X ? lineStartPoint : lineEndPoint; Point rightPoint = lineEndPoint.X > lineStartPoint.X ? lineEndPoint : lineStartPoint; Point barPoint = new Point(firstBarX, firstBarY); // NOTE: 'left / right' is relative to if line was vertical. it can end up backwards too MathHelper.PointLineLocation pointLocation = MathHelper.GetPointLineLocation(leftPoint, rightPoint, barPoint); // for vertical things, think of a vertical line rotated 90 degrees to lay flat, where it's normal vector is 'up' switch (condition) { case Condition.Greater: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove); case Condition.GreaterEqual: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Less: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow); case Condition.LessEqual: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Equals: return(pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.NotEqual: return(pointLocation != MathHelper.PointLineLocation.DirectlyOnLine); case Condition.CrossAbove: case Condition.CrossBelow: Predicate <ChartAlertValue> predicate = v => { double barX = chartControl.GetXByTime(v.Time); double barY = chartScale.GetYByValue(v.Value); Point stepBarPoint = new Point(barX, barY); MathHelper.PointLineLocation ptLocation = MathHelper.GetPointLineLocation(leftPoint, rightPoint, stepBarPoint); if (condition == Condition.CrossAbove) { return(ptLocation == MathHelper.PointLineLocation.LeftOrAbove); } return(ptLocation == MathHelper.PointLineLocation.RightOrBelow); }; return(MathHelper.DidPredicateCross(values, predicate)); } return(false); }
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { // dig up which anchor we are running on to determine line ChartAnchor chartAnchor = conditionItem.Tag as ChartAnchor; if (chartAnchor == null) { return(false); } ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; double alertY = chartScale.GetYByValue(chartAnchor.Price); Point entryPoint = EntryAnchor.GetPoint(chartControl, chartPanel, chartScale); Point stopPoint = RiskAnchor.GetPoint(chartControl, chartPanel, chartScale); Point targetPoint = RewardAnchor.GetPoint(chartControl, chartPanel, chartScale); double anchorMinX = DrawTarget ? new[] { entryPoint.X, stopPoint.X, targetPoint.X }.Min() : new[] { entryPoint.X, stopPoint.X }.Min(); double anchorMaxX = DrawTarget ? new[] { entryPoint.X, stopPoint.X, targetPoint.X }.Max() : new[] { entryPoint.X, stopPoint.X }.Max(); double lineStartX = IsExtendedLinesLeft ? chartPanel.X : anchorMinX; double lineEndX = IsExtendedLinesRight ? chartPanel.X + chartPanel.W : anchorMaxX; // first thing, if our smallest x is greater than most recent bar, we have nothing to do yet. // do not try to check Y because lines could cross through stuff double firstBarX = chartControl.GetXByTime(values[0].Time); double firstBarY = chartScale.GetYByValue(values[0].Value); if (lineEndX < firstBarX) // bars passed our drawing tool { return(false); } Point lineStartPoint = new Point(lineStartX, alertY); Point lineEndPoint = new Point(lineEndX, alertY); Point barPoint = new Point(firstBarX, firstBarY); // NOTE: 'left / right' is relative to if line was vertical. it can end up backwards too MathHelper.PointLineLocation pointLocation = MathHelper.GetPointLineLocation(lineStartPoint, lineEndPoint, barPoint); // for vertical things, think of a vertical line rotated 90 degrees to lay flat, where it's normal vector is 'up' switch (condition) { case Condition.Greater: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove); case Condition.GreaterEqual: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Less: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow); case Condition.LessEqual: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Equals: return(pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.NotEqual: return(pointLocation != MathHelper.PointLineLocation.DirectlyOnLine); case Condition.CrossAbove: case Condition.CrossBelow: Predicate <ChartAlertValue> predicate = v => { double barX = chartControl.GetXByTime(v.Time); double barY = chartScale.GetYByValue(v.Value); Point stepBarPoint = new Point(barX, barY); // NOTE: 'left / right' is relative to if line was vertical. it can end up backwards too MathHelper.PointLineLocation ptLocation = MathHelper.GetPointLineLocation(lineStartPoint, lineEndPoint, stepBarPoint); if (condition == Condition.CrossAbove) { return(ptLocation == MathHelper.PointLineLocation.LeftOrAbove); } return(ptLocation == MathHelper.PointLineLocation.RightOrBelow); }; return(MathHelper.DidPredicateCross(values, predicate)); } return(false); }
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { GannAngle gannAngle = conditionItem.Tag as GannAngle; if (gannAngle == null) { return(false); } ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; Point anchorPoint = Anchor.GetPoint(chartControl, chartPanel, chartScale); // dig out the line we're running on double dx = gannAngle.RatioX * chartControl.Properties.BarDistance; double dVal = chartScale.GetPixelsForDistance(gannAngle.RatioY * chartControl.Instrument.MasterInstrument.TickSize); Point stepPoint = GetGannStepPoint(chartScale, anchorPoint.X, Anchor.Price, dx, dVal); Point extendedEndPoint = GetExtendedPoint(anchorPoint, stepPoint); if (values[0].ValueType == ChartAlertValueType.StaticTime) { int checkX = chartControl.GetXByTime(values[0].Time); return(stepPoint.X >= checkX || stepPoint.X >= checkX); } double barX = chartControl.GetXByTime(values[0].Time); double barY = chartScale.GetYByValue(values[0].Value); Point barPoint = new Point(barX, barY); // bars passed our drawing tool line if (extendedEndPoint.X < barX) { return(false); } // bars not yet to our drawing tool line if (stepPoint.X > barY) { return(false); } if (condition == Condition.CrossAbove || condition == Condition.CrossBelow) { Predicate <ChartAlertValue> predicate = v => { // bar x/y double bX = chartControl.GetXByTime(v.Time); double bY = chartScale.GetYByValue(v.Value); Point stepBarPoint = new Point(bX, bY); // NOTE: 'left / right' is relative to if line was vertical. it can end up backwards too MathHelper.PointLineLocation ptLocation = MathHelper.GetPointLineLocation(anchorPoint, extendedEndPoint, stepBarPoint); if (condition == Condition.CrossAbove) { return(ptLocation == MathHelper.PointLineLocation.LeftOrAbove); } return(ptLocation == MathHelper.PointLineLocation.RightOrBelow); }; return(MathHelper.DidPredicateCross(values, predicate)); } MathHelper.PointLineLocation pointLocation = MathHelper.GetPointLineLocation(anchorPoint, extendedEndPoint, barPoint); switch (condition) { case Condition.Greater: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove); case Condition.GreaterEqual: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Less: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow); case Condition.LessEqual: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Equals: return(pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.NotEqual: return(pointLocation != MathHelper.PointLineLocation.DirectlyOnLine); default: return(false); } }
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values, ChartControl chartControl, ChartScale chartScale) { PriceLevel priceLevel = conditionItem.Tag as PriceLevel; if (priceLevel == null) { return(false); } ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex]; Point anchorStartPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale); Point anchorEndPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale); Point anchorExtensionPoint = ExtensionAnchor.GetPoint(chartControl, chartPanel, chartScale); Point midPointExtension = new Point((anchorExtensionPoint.X + anchorEndPoint.X) / 2, (anchorExtensionPoint.Y + anchorEndPoint.Y) / 2); if (CalculationMethod == AndrewsPitchforkCalculationMethod.Schiff) { anchorStartPoint = new Point(anchorStartPoint.X, (anchorStartPoint.Y + anchorEndPoint.Y) / 2); } else if (CalculationMethod == AndrewsPitchforkCalculationMethod.ModifiedSchiff) { anchorStartPoint = new Point((anchorEndPoint.X + anchorStartPoint.X) / 2, (anchorEndPoint.Y + anchorStartPoint.Y) / 2); } double totalPriceRange = EndAnchor.Price - ExtensionAnchor.Price; double startPrice = ExtensionAnchor.Price; double levelPrice = (startPrice + ((priceLevel.Value / 100) * totalPriceRange)); float pixelY = chartScale.GetYByValue(levelPrice); float pixelX = anchorExtensionPoint.X > anchorEndPoint.X ? (float)(anchorExtensionPoint.X - (Math.Abs((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100)))) : (float)(anchorExtensionPoint.X + ((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100))); Point alertStartPoint = new Point(pixelX, pixelY); Point endPoint = new Point(alertStartPoint.X + (midPointExtension.X - anchorStartPoint.X), alertStartPoint.Y + (midPointExtension.Y - anchorStartPoint.Y)); Point alertEndPoint = GetExtendedPoint(alertStartPoint, endPoint); double firstBarX = values[0].ValueType == ChartAlertValueType.StaticValue ? pixelX : chartControl.GetXByTime(values[0].Time); double firstBarY = chartScale.GetYByValue(values[0].Value); Point barPoint = new Point(firstBarX, firstBarY); // Check bars are not yet to our drawing tool if (firstBarX < alertStartPoint.X || firstBarX > alertEndPoint.X) { return(false); } // NOTE: 'left / right' is relative to if line was vertical. It can end up backwards too MathHelper.PointLineLocation pointLocation = MathHelper.GetPointLineLocation(alertStartPoint, alertEndPoint, barPoint); // For vertical things, think of a vertical line rotated 90 degrees to lay flat, where it's normal vector is 'up' switch (condition) { case Condition.Greater: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove); case Condition.GreaterEqual: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Less: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow); case Condition.LessEqual: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.Equals: return(pointLocation == MathHelper.PointLineLocation.DirectlyOnLine); case Condition.NotEqual: return(pointLocation != MathHelper.PointLineLocation.DirectlyOnLine); case Condition.CrossAbove: case Condition.CrossBelow: Predicate <ChartAlertValue> predicate = v => { double barX = chartControl.GetXByTime(v.Time); double barY = chartScale.GetYByValue(v.Value); Point stepBarPoint = new Point(barX, barY); // NOTE: 'left / right' is relative to if line was vertical. It can end up backwards too MathHelper.PointLineLocation ptLocation = MathHelper.GetPointLineLocation(alertStartPoint, alertEndPoint, stepBarPoint); if (condition == Condition.CrossAbove) { return(ptLocation == MathHelper.PointLineLocation.LeftOrAbove); } return(ptLocation == MathHelper.PointLineLocation.RightOrBelow); }; return(MathHelper.DidPredicateCross(values, predicate)); } return(false); }