/// <summary>
/// Gets the nearest point.
/// </summary>
/// <param name="points">
/// The points (data coordinates).
/// </param>
/// <param name="point">
/// The point (screen coordinates).
/// </param>
/// <returns>
/// True if a point was found.
/// </returns>
protected TrackerHitResult GetNearestPointInternal(IEnumerable <IDataPoint> points, ScreenPoint point)
{
var spn = default(ScreenPoint);
IDataPoint dpn = default(DataPoint);
double index = -1;
double minimumDistance = double.MaxValue;
int i = 0;
foreach (IDataPoint p in points)
{
if (!this.IsValidPoint(p, this.XAxis, this.YAxis))
{
continue;
}
var sp = Axis.Transform(p, this.XAxis, this.YAxis);
double d2 = (sp - point).LengthSquared;
if (d2 < minimumDistance)
{
dpn = p;
spn = sp;
minimumDistance = d2;
index = i;
}
i++;
}
if (minimumDistance < double.MaxValue)
{
object item = this.GetItem((int)index);
return(new TrackerHitResult(this, dpn, spn, item)
{
Index = index
});
}
return(null);
}
private void RenderMagnitudeAxis(Axis axis, Axis angleAxis)
{
if (axis.RelatedAxis != null)
{
angleAxis = axis.RelatedAxis;
}
if (axis.ShowMinorTicks)
{
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out y0, out y1);
foreach (double xValue in minorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
if (majorTickValues.Contains(xValue))
{
continue;
}
var pts = new List <ScreenPoint>();
for (double th = angleAxis.ActualMinimum;
th <= angleAxis.ActualMaximum;
th += angleAxis.MinorStep * 0.1)
{
pts.Add(axis.Transform(xValue, th, angleAxis));
}
if (minorPen != null)
{
rc.DrawLine(pts, minorPen.Color, minorPen.Thickness, minorPen.DashArray);
}
// RenderGridline(x, y + y0, x, y + y1, minorTickPen);
}
}
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out y0, out y1);
foreach (double xValue in majorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
var pts = new List <ScreenPoint>();
for (double th = angleAxis.ActualMinimum; th <= angleAxis.ActualMaximum; th += angleAxis.MinorStep * 0.1)
{
pts.Add(axis.Transform(xValue, th, angleAxis));
}
if (majorPen != null)
{
rc.DrawLine(pts, majorPen.Color, majorPen.Thickness, majorPen.DashArray);
}
// RenderGridline(x, y + y0, x, y + y1, majorTickPen);
//var pt = new ScreenPoint(x, istop ? y + y1 - TICK_DIST : y + y1 + TICK_DIST);
//string text = axis.FormatValue(xValue);
//double h = rc.MeasureText(text, axis.FontFamily, axis.FontSize, axis.FontWeight).Height;
//rc.DrawText(pt, text, plot.TextColor,
// axis.FontFamily, axis.FontSize, axis.FontWeight,
// axis.Angle,
// HorizontalTextAlign.Center, istop ? VerticalTextAlign.Bottom : VerticalTextAlign.Top);
//maxh = Math.Max(maxh, h);
}
}
private void RenderAngleAxis(Axis axis, Axis magnitudeAxis)
{
if (axis.RelatedAxis != null)
{
magnitudeAxis = axis.RelatedAxis;
}
if (axis.ShowMinorTicks)
{
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out y0, out y1);
foreach (double xValue in minorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
if (majorTickValues.Contains(xValue))
{
continue;
}
var pt = magnitudeAxis.Transform(magnitudeAxis.ActualMaximum, xValue, axis);
if (minorPen != null)
{
RenderLine(axis.MidPoint.x, axis.MidPoint.y, pt.x, pt.y, minorPen, false);
}
// RenderGridline(x, y + y0, x, y + y1, minorTickPen);
}
}
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out y0, out y1);
foreach (double xValue in majorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
var pt = magnitudeAxis.Transform(magnitudeAxis.ActualMaximum, xValue, axis);
if (majorPen != null)
{
RenderLine(axis.MidPoint.x, axis.MidPoint.y, pt.x, pt.y, majorPen, false);
}
// RenderGridline(x, y + y0, x, y + y1, majorTickPen);
//var pt = new ScreenPoint(x, istop ? y + y1 - TICK_DIST : y + y1 + TICK_DIST);
//string text = axis.FormatValue(xValue);
//double h = rc.MeasureText(text, axis.FontFamily, axis.FontSize, axis.FontWeight).Height;
//rc.DrawText(pt, text, plot.TextColor,
// axis.FontFamily, axis.FontSize, axis.FontWeight,
// axis.Angle,
// HorizontalTextAlign.Center, istop ? VerticalTextAlign.Bottom : VerticalTextAlign.Top);
//maxh = Math.Max(maxh, h);
}
}
/// <summary>
/// Renders the specified axis.
/// </summary>
/// <param name="axis">The axis.</param>
/// <param name="pass">The pass.</param>
/// <exception cref="System.NullReferenceException">Angle axis should not be null.</exception>
public override void Render(Axis axis, int pass)
{
base.Render(axis, pass);
var angleAxis = this.Plot.DefaultAngleAxis as Axis;
if (axis.RelatedAxis != null)
{
angleAxis = axis.RelatedAxis;
}
if (angleAxis == null)
{
throw new NullReferenceException("Angle axis should not be null.");
}
if (axis.ShowMinorTicks)
{
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out y0, out y1);
foreach (double xValue in this.MinorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
if (this.MajorTickValues.Contains(xValue))
{
continue;
}
var pts = new List <ScreenPoint>();
for (double th = angleAxis.ActualMinimum;
th <= angleAxis.ActualMaximum + angleAxis.MinorStep * 0.01;
th += angleAxis.MinorStep * 0.1)
{
pts.Add(axis.Transform(xValue, th, angleAxis));
}
if (this.MinorPen != null)
{
this.rc.DrawLine(pts, this.MinorPen.Color, this.MinorPen.Thickness, this.MinorPen.DashArray);
}
// RenderGridline(x, y + y0, x, y + y1, minorTickPen);
}
}
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out y0, out y1);
foreach (double xValue in this.MajorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
var pts = new List <ScreenPoint>();
for (double th = angleAxis.ActualMinimum;
th <= angleAxis.ActualMaximum + angleAxis.MinorStep * 0.01;
th += angleAxis.MinorStep * 0.1)
{
pts.Add(axis.Transform(xValue, th, angleAxis));
}
if (this.MajorPen != null)
{
this.rc.DrawLine(pts, this.MajorPen.Color, this.MajorPen.Thickness, this.MajorPen.DashArray);
}
// RenderGridline(x, y + y0, x, y + y1, majorTickPen);
// var pt = new ScreenPoint(x, istop ? y + y1 - TICK_DIST : y + y1 + TICK_DIST);
// string text = axis.FormatValue(xValue);
// double h = rc.MeasureText(text, axis.Font, axis.FontSize, axis.FontWeight).Height;
// rc.DrawText(pt, text, axis.LabelColor ?? plot.TextColor,
// axis.Font, axis.FontSize, axis.FontWeight,
// axis.Angle,
// HorizontalAlignment.Center, istop ? VerticalAlignment.Bottom : VerticalAlignment.Top);
// maxh = Math.Max(maxh, h);
}
}
/// <summary>
/// Transforms the specified point to screen coordinates.
/// </summary>
/// <param name="p">
/// The point.
/// </param>
/// <param name="xaxis">
/// The x axis.
/// </param>
/// <param name="yaxis">
/// The y axis.
/// </param>
/// <returns>
/// The transformed point.
/// </returns>
public static ScreenPoint Transform(IDataPoint p, Axis xaxis, Axis yaxis)
{
return xaxis.Transform(p.X, p.Y, yaxis);
}
/// <summary>
/// Transforms the specified point to screen coordinates.
/// </summary>
/// <param name="x">
/// The x value (for the current axis).
/// </param>
/// <param name="y">
/// The y value.
/// </param>
/// <param name="yaxis">
/// The y axis.
/// </param>
/// <returns>
/// The transformed point.
/// </returns>
public virtual ScreenPoint Transform(double x, double y, Axis yaxis)
{
if (yaxis == null)
{
throw new NullReferenceException("Y axis should not be null when transforming.");
}
return new ScreenPoint(this.Transform(x), yaxis.Transform(y));
}
/// <summary>
/// Renders the minor items.
/// </summary>
/// <param name="axis">
/// The axis.
/// </param>
/// <param name="axisPosition">
/// The axis position.
/// </param>
private void RenderMinorItems(Axis axis, double axisPosition)
{
double eps = axis.ActualMinorStep * 1e-3;
double actualMinimum = axis.ActualMinimum;
double actualMaximum = axis.ActualMaximum;
double plotAreaLeft = this.Plot.PlotArea.Left;
double plotAreaRight = this.Plot.PlotArea.Right;
double plotAreaTop = this.Plot.PlotArea.Top;
double plotAreaBottom = this.Plot.PlotArea.Bottom;
bool isHorizontal = axis.IsHorizontal();
double a0;
double a1;
var minorSegments = new List <ScreenPoint>();
var minorTickSegments = new List <ScreenPoint>();
this.GetTickPositions(axis, axis.TickStyle, axis.MinorTickSize, axis.Position, out a0, out a1);
foreach (double value in this.MinorTickValues)
{
if (value < actualMinimum - eps || value > actualMaximum + eps)
{
continue;
}
if (this.MajorTickValues.Contains(value))
{
continue;
}
if (axis.PositionAtZeroCrossing && Math.Abs(value) < eps)
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
SnapTo(plotAreaLeft, ref transformedValue);
SnapTo(plotAreaRight, ref transformedValue);
}
else
{
SnapTo(plotAreaTop, ref transformedValue);
SnapTo(plotAreaBottom, ref transformedValue);
}
// Draw the minor grid line
if (this.MinorPen != null)
{
if (isHorizontal)
{
minorSegments.Add(new ScreenPoint(transformedValue, plotAreaTop));
minorSegments.Add(new ScreenPoint(transformedValue, plotAreaBottom));
}
else
{
if (transformedValue < plotAreaTop || transformedValue > plotAreaBottom)
{
}
minorSegments.Add(new ScreenPoint(plotAreaLeft, transformedValue));
minorSegments.Add(new ScreenPoint(plotAreaRight, transformedValue));
}
}
// Draw the minor tick
if (axis.TickStyle != TickStyle.None)
{
if (isHorizontal)
{
minorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a0));
minorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a1));
}
else
{
minorTickSegments.Add(new ScreenPoint(axisPosition + a0, transformedValue));
minorTickSegments.Add(new ScreenPoint(axisPosition + a1, transformedValue));
}
}
}
// Draw all the line segments);
if (this.MinorPen != null)
{
this.rc.DrawLineSegments(minorSegments, this.MinorPen);
}
if (this.MinorTickPen != null)
{
this.rc.DrawLineSegments(minorTickSegments, this.MinorTickPen);
}
}
/// <summary>
/// Renders the major items.
/// </summary>
/// <param name="axis">
/// The axis.
/// </param>
/// <param name="axisPosition">
/// The axis position.
/// </param>
/// <param name="titlePosition">
/// The title position.
/// </param>
private void RenderMajorItems(Axis axis, double axisPosition, double titlePosition)
{
double eps = axis.ActualMinorStep * 1e-3;
double actualMinimum = axis.ActualMinimum;
double actualMaximum = axis.ActualMaximum;
double plotAreaLeft = this.Plot.PlotArea.Left;
double plotAreaRight = this.Plot.PlotArea.Right;
double plotAreaTop = this.Plot.PlotArea.Top;
double plotAreaBottom = this.Plot.PlotArea.Bottom;
bool isHorizontal = axis.IsHorizontal();
double a0;
double a1;
var majorSegments = new List <ScreenPoint>();
var majorTickSegments = new List <ScreenPoint>();
this.GetTickPositions(axis, axis.TickStyle, axis.MajorTickSize, axis.Position, out a0, out a1);
foreach (double value in this.MajorTickValues)
{
if (value < actualMinimum - eps || value > actualMaximum + eps)
{
continue;
}
if (axis.PositionAtZeroCrossing && Math.Abs(value) < eps)
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
SnapTo(plotAreaLeft, ref transformedValue);
SnapTo(plotAreaRight, ref transformedValue);
}
else
{
SnapTo(plotAreaTop, ref transformedValue);
SnapTo(plotAreaBottom, ref transformedValue);
}
if (this.MajorPen != null)
{
if (isHorizontal)
{
majorSegments.Add(new ScreenPoint(transformedValue, plotAreaTop));
majorSegments.Add(new ScreenPoint(transformedValue, plotAreaBottom));
}
else
{
majorSegments.Add(new ScreenPoint(plotAreaLeft, transformedValue));
majorSegments.Add(new ScreenPoint(plotAreaRight, transformedValue));
}
}
if (axis.TickStyle != TickStyle.None)
{
if (isHorizontal)
{
majorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a0));
majorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a1));
}
else
{
majorTickSegments.Add(new ScreenPoint(axisPosition + a0, transformedValue));
majorTickSegments.Add(new ScreenPoint(axisPosition + a1, transformedValue));
}
}
}
// Render the axis labels (numbers or category names)
foreach (double value in this.MajorLabelValues)
{
if (value < actualMinimum - eps || value > actualMaximum + eps)
{
continue;
}
if (axis.PositionAtZeroCrossing && Math.Abs(value) < eps)
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
SnapTo(plotAreaLeft, ref transformedValue);
SnapTo(plotAreaRight, ref transformedValue);
}
else
{
SnapTo(plotAreaTop, ref transformedValue);
SnapTo(plotAreaBottom, ref transformedValue);
}
var pt = new ScreenPoint();
var ha = HorizontalAlignment.Right;
var va = VerticalAlignment.Middle;
switch (axis.Position)
{
case AxisPosition.Left:
pt = new ScreenPoint(axisPosition + a1 - axis.AxisTickToLabelDistance, transformedValue);
this.GetRotatedAlignments(
axis.Angle, HorizontalAlignment.Right, VerticalAlignment.Middle, out ha, out va);
break;
case AxisPosition.Right:
pt = new ScreenPoint(axisPosition + a1 + axis.AxisTickToLabelDistance, transformedValue);
this.GetRotatedAlignments(
axis.Angle, HorizontalAlignment.Left, VerticalAlignment.Middle, out ha, out va);
break;
case AxisPosition.Top:
pt = new ScreenPoint(transformedValue, axisPosition + a1 - axis.AxisTickToLabelDistance);
this.GetRotatedAlignments(
axis.Angle, HorizontalAlignment.Center, VerticalAlignment.Bottom, out ha, out va);
break;
case AxisPosition.Bottom:
pt = new ScreenPoint(transformedValue, axisPosition + a1 + axis.AxisTickToLabelDistance);
this.GetRotatedAlignments(
axis.Angle, HorizontalAlignment.Center, VerticalAlignment.Top, out ha, out va);
break;
}
string text = axis.FormatValue(value);
this.rc.DrawMathText(
pt,
text,
axis.ActualTextColor,
axis.ActualFont,
axis.ActualFontSize,
axis.ActualFontWeight,
axis.Angle,
ha,
va);
}
// Draw the zero crossing line
if (axis.PositionAtZeroCrossing && this.ZeroPen != null)
{
double t0 = axis.Transform(0);
if (isHorizontal)
{
this.rc.DrawLine(t0, plotAreaTop, t0, plotAreaBottom, this.ZeroPen);
}
else
{
this.rc.DrawLine(plotAreaLeft, t0, plotAreaRight, t0, this.ZeroPen);
}
}
// Draw extra grid lines
if (axis.ExtraGridlines != null && this.ExtraPen != null)
{
foreach (double value in axis.ExtraGridlines)
{
if (!this.IsWithin(value, actualMinimum, actualMaximum))
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
this.rc.DrawLine(transformedValue, plotAreaTop, transformedValue, plotAreaBottom, this.ExtraPen);
}
else
{
this.rc.DrawLine(plotAreaLeft, transformedValue, plotAreaRight, transformedValue, this.ExtraPen);
}
}
}
// Draw the axis line (across the tick marks)
if (isHorizontal)
{
this.rc.DrawLine(
axis.Transform(actualMinimum),
axisPosition,
axis.Transform(actualMaximum),
axisPosition,
this.AxislinePen);
}
else
{
this.rc.DrawLine(
axisPosition,
axis.Transform(actualMinimum),
axisPosition,
axis.Transform(actualMaximum),
this.AxislinePen);
}
// Draw the axis title
if (!string.IsNullOrEmpty(axis.ActualTitle))
{
this.RenderAxisTitle(axis, titlePosition);
}
if (this.MajorPen != null)
{
this.rc.DrawLineSegments(majorSegments, this.MajorPen);
}
if (this.MajorTickPen != null)
{
this.rc.DrawLineSegments(majorTickSegments, this.MajorTickPen);
}
}
private void RenderMagnitudeAxis(Axis axis, Axis angleAxis)
{
if (axis.RelatedAxis != null)
angleAxis = axis.RelatedAxis;
if (axis.ShowMinorTicks)
{
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out y0, out y1);
foreach (double xValue in minorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
if (majorTickValues.Contains(xValue))
{
continue;
}
var pts = new List<ScreenPoint>();
for (double th = angleAxis.ActualMinimum;
th <= angleAxis.ActualMaximum;
th += angleAxis.MinorStep*0.1)
{
pts.Add(axis.Transform(xValue, th, angleAxis));
}
if (minorPen != null)
{
rc.DrawLine(pts, minorPen.Color, minorPen.Thickness, minorPen.DashArray);
}
// RenderGridline(x, y + y0, x, y + y1, minorTickPen);
}
}
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out y0, out y1);
foreach (double xValue in majorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
var pts = new List<ScreenPoint>();
for (double th = angleAxis.ActualMinimum; th <= angleAxis.ActualMaximum; th += angleAxis.MinorStep*0.1)
{
pts.Add(axis.Transform(xValue, th, angleAxis));
}
if (majorPen != null)
{
rc.DrawLine(pts, majorPen.Color, majorPen.Thickness, majorPen.DashArray);
}
// RenderGridline(x, y + y0, x, y + y1, majorTickPen);
//var pt = new ScreenPoint(x, istop ? y + y1 - TICK_DIST : y + y1 + TICK_DIST);
//string text = axis.FormatValue(xValue);
//double h = rc.MeasureText(text, axis.FontFamily, axis.FontSize, axis.FontWeight).Height;
//rc.DrawText(pt, text, plot.TextColor,
// axis.FontFamily, axis.FontSize, axis.FontWeight,
// axis.Angle,
// HorizontalTextAlign.Center, istop ? VerticalTextAlign.Bottom : VerticalTextAlign.Top);
//maxh = Math.Max(maxh, h);
}
}
private void RenderAngleAxis(Axis axis, Axis magnitudeAxis)
{
if (axis.RelatedAxis != null)
magnitudeAxis = axis.RelatedAxis;
if (axis.ShowMinorTicks)
{
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MinorTickSize, out y0, out y1);
foreach (double xValue in minorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
if (majorTickValues.Contains(xValue))
{
continue;
}
var pt = magnitudeAxis.Transform(magnitudeAxis.ActualMaximum, xValue, axis);
if (minorPen != null)
{
RenderLine(axis.MidPoint.x, axis.MidPoint.y, pt.x, pt.y, minorPen, false);
}
// RenderGridline(x, y + y0, x, y + y1, minorTickPen);
}
}
// GetVerticalTickPositions(axis, axis.TickStyle, axis.MajorTickSize, out y0, out y1);
foreach (double xValue in majorTickValues)
{
if (xValue < axis.ActualMinimum || xValue > axis.ActualMaximum)
{
continue;
}
var pt = magnitudeAxis.Transform(magnitudeAxis.ActualMaximum, xValue, axis);
if (majorPen != null)
{
RenderLine(axis.MidPoint.x, axis.MidPoint.y, pt.x, pt.y, majorPen, false);
}
// RenderGridline(x, y + y0, x, y + y1, majorTickPen);
//var pt = new ScreenPoint(x, istop ? y + y1 - TICK_DIST : y + y1 + TICK_DIST);
//string text = axis.FormatValue(xValue);
//double h = rc.MeasureText(text, axis.FontFamily, axis.FontSize, axis.FontWeight).Height;
//rc.DrawText(pt, text, plot.TextColor,
// axis.FontFamily, axis.FontSize, axis.FontWeight,
// axis.Angle,
// HorizontalTextAlign.Center, istop ? VerticalTextAlign.Bottom : VerticalTextAlign.Top);
//maxh = Math.Max(maxh, h);
}
}
/// <summary>
/// Renders the minor items.
/// </summary>
/// <param name="axis">
/// The axis.
/// </param>
/// <param name="axisPosition">
/// The axis position.
/// </param>
private void RenderMinorItems(Axis axis, double axisPosition)
{
double eps = axis.ActualMinorStep * 1e-3;
double actualMinimum = axis.ActualMinimum;
double actualMaximum = axis.ActualMaximum;
double plotAreaLeft = this.Plot.PlotArea.Left;
double plotAreaRight = this.Plot.PlotArea.Right;
double plotAreaTop = this.Plot.PlotArea.Top;
double plotAreaBottom = this.Plot.PlotArea.Bottom;
bool isHorizontal = axis.IsHorizontal();
double a0;
double a1;
var minorSegments = new List<ScreenPoint>();
var minorTickSegments = new List<ScreenPoint>();
this.GetTickPositions(axis, axis.TickStyle, axis.MinorTickSize, axis.Position, out a0, out a1);
foreach (double value in this.MinorTickValues)
{
if (value < actualMinimum - eps || value > actualMaximum + eps)
{
continue;
}
if (this.MajorTickValues.Contains(value))
{
continue;
}
if (axis.PositionAtZeroCrossing && Math.Abs(value) < eps)
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
SnapTo(plotAreaLeft, ref transformedValue);
SnapTo(plotAreaRight, ref transformedValue);
}
else
{
SnapTo(plotAreaTop, ref transformedValue);
SnapTo(plotAreaBottom, ref transformedValue);
}
// Draw the minor grid line
if (this.MinorPen != null)
{
if (isHorizontal)
{
minorSegments.Add(new ScreenPoint(transformedValue, plotAreaTop));
minorSegments.Add(new ScreenPoint(transformedValue, plotAreaBottom));
}
else
{
if (transformedValue < plotAreaTop || transformedValue > plotAreaBottom)
{
}
minorSegments.Add(new ScreenPoint(plotAreaLeft, transformedValue));
minorSegments.Add(new ScreenPoint(plotAreaRight, transformedValue));
}
}
// Draw the minor tick
if (axis.TickStyle != TickStyle.None)
{
if (isHorizontal)
{
minorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a0));
minorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a1));
}
else
{
minorTickSegments.Add(new ScreenPoint(axisPosition + a0, transformedValue));
minorTickSegments.Add(new ScreenPoint(axisPosition + a1, transformedValue));
}
}
}
// Draw all the line segments);
if (this.MinorPen != null)
{
this.rc.DrawLineSegments(minorSegments, this.MinorPen);
}
if (this.MinorTickPen != null)
{
this.rc.DrawLineSegments(minorTickSegments, this.MinorTickPen);
}
}
/// <summary>
/// Renders the major items.
/// </summary>
/// <param name="axis">
/// The axis.
/// </param>
/// <param name="axisPosition">
/// The axis position.
/// </param>
/// <param name="titlePosition">
/// The title position.
/// </param>
private void RenderMajorItems(Axis axis, double axisPosition, double titlePosition)
{
double eps = axis.ActualMinorStep * 1e-3;
double actualMinimum = axis.ActualMinimum;
double actualMaximum = axis.ActualMaximum;
double plotAreaLeft = this.Plot.PlotArea.Left;
double plotAreaRight = this.Plot.PlotArea.Right;
double plotAreaTop = this.Plot.PlotArea.Top;
double plotAreaBottom = this.Plot.PlotArea.Bottom;
bool isHorizontal = axis.IsHorizontal();
double a0;
double a1;
var majorSegments = new List<ScreenPoint>();
var majorTickSegments = new List<ScreenPoint>();
this.GetTickPositions(axis, axis.TickStyle, axis.MajorTickSize, axis.Position, out a0, out a1);
foreach (double value in this.MajorTickValues)
{
if (value < actualMinimum - eps || value > actualMaximum + eps)
{
continue;
}
if (axis.PositionAtZeroCrossing && Math.Abs(value) < eps)
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
SnapTo(plotAreaLeft, ref transformedValue);
SnapTo(plotAreaRight, ref transformedValue);
}
else
{
SnapTo(plotAreaTop, ref transformedValue);
SnapTo(plotAreaBottom, ref transformedValue);
}
if (this.MajorPen != null)
{
if (isHorizontal)
{
majorSegments.Add(new ScreenPoint(transformedValue, plotAreaTop));
majorSegments.Add(new ScreenPoint(transformedValue, plotAreaBottom));
}
else
{
majorSegments.Add(new ScreenPoint(plotAreaLeft, transformedValue));
majorSegments.Add(new ScreenPoint(plotAreaRight, transformedValue));
}
}
if (axis.TickStyle != TickStyle.None)
{
if (isHorizontal)
{
majorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a0));
majorTickSegments.Add(new ScreenPoint(transformedValue, axisPosition + a1));
}
else
{
majorTickSegments.Add(new ScreenPoint(axisPosition + a0, transformedValue));
majorTickSegments.Add(new ScreenPoint(axisPosition + a1, transformedValue));
}
}
}
// Render the axis labels (numbers or category names)
foreach (double value in this.MajorLabelValues)
{
if (value < actualMinimum - eps || value > actualMaximum + eps)
{
continue;
}
if (axis.PositionAtZeroCrossing && Math.Abs(value) < eps)
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
SnapTo(plotAreaLeft, ref transformedValue);
SnapTo(plotAreaRight, ref transformedValue);
}
else
{
SnapTo(plotAreaTop, ref transformedValue);
SnapTo(plotAreaBottom, ref transformedValue);
}
var pt = new ScreenPoint();
var ha = HorizontalTextAlign.Right;
var va = VerticalTextAlign.Middle;
switch (axis.Position)
{
case AxisPosition.Left:
pt = new ScreenPoint(axisPosition + a1 - axis.AxisTickToLabelDistance, transformedValue);
this.GetRotatedAlignments(
axis.Angle, HorizontalTextAlign.Right, VerticalTextAlign.Middle, out ha, out va);
break;
case AxisPosition.Right:
pt = new ScreenPoint(axisPosition + a1 + axis.AxisTickToLabelDistance, transformedValue);
this.GetRotatedAlignments(
axis.Angle, HorizontalTextAlign.Left, VerticalTextAlign.Middle, out ha, out va);
break;
case AxisPosition.Top:
pt = new ScreenPoint(transformedValue, axisPosition + a1 - axis.AxisTickToLabelDistance);
this.GetRotatedAlignments(
axis.Angle, HorizontalTextAlign.Center, VerticalTextAlign.Bottom, out ha, out va);
break;
case AxisPosition.Bottom:
pt = new ScreenPoint(transformedValue, axisPosition + a1 + axis.AxisTickToLabelDistance);
this.GetRotatedAlignments(
axis.Angle, HorizontalTextAlign.Center, VerticalTextAlign.Top, out ha, out va);
break;
}
string text = axis.FormatValue(value);
this.rc.DrawMathText(
pt,
text,
axis.ActualTextColor,
axis.ActualFont,
axis.ActualFontSize,
axis.ActualFontWeight,
axis.Angle,
ha,
va);
}
// Draw the zero crossing line
if (axis.PositionAtZeroCrossing && this.ZeroPen != null)
{
double t0 = axis.Transform(0);
if (isHorizontal)
{
this.rc.DrawLine(t0, plotAreaTop, t0, plotAreaBottom, this.ZeroPen);
}
else
{
this.rc.DrawLine(plotAreaLeft, t0, plotAreaRight, t0, this.ZeroPen);
}
}
// Draw extra grid lines
if (axis.ExtraGridlines != null && this.ExtraPen != null)
{
foreach (double value in axis.ExtraGridlines)
{
if (!this.IsWithin(value, actualMinimum, actualMaximum))
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
this.rc.DrawLine(transformedValue, plotAreaTop, transformedValue, plotAreaBottom, this.ExtraPen);
}
else
{
this.rc.DrawLine(plotAreaLeft, transformedValue, plotAreaRight, transformedValue, this.ExtraPen);
}
}
}
// Draw the axis line (across the tick marks)
if (isHorizontal)
{
this.rc.DrawLine(
axis.Transform(actualMinimum),
axisPosition,
axis.Transform(actualMaximum),
axisPosition,
this.AxislinePen);
}
else
{
this.rc.DrawLine(
axisPosition,
axis.Transform(actualMinimum),
axisPosition,
axis.Transform(actualMaximum),
this.AxislinePen);
}
// Draw the axis title
if (!string.IsNullOrEmpty(axis.ActualTitle))
{
this.RenderAxisTitle(axis, titlePosition);
}
if (this.MajorPen != null)
{
this.rc.DrawLineSegments(majorSegments, this.MajorPen);
}
if (this.MajorTickPen != null)
{
this.rc.DrawLineSegments(majorTickSegments, this.MajorTickPen);
}
}
public override void Render(Axis axis)
{
base.Render(axis);
var perpendicularAxis = Plot.DefaultXAxis;
bool isHorizontal = true;
// Axis position (x or y screen coordinate)
double apos = 0;
switch (axis.Position)
{
case AxisPosition.Left:
apos = Plot.PlotArea.Left;
isHorizontal = false;
break;
case AxisPosition.Right:
apos = Plot.PlotArea.Right;
isHorizontal = false;
break;
case AxisPosition.Top:
apos = Plot.PlotArea.Top;
perpendicularAxis = Plot.DefaultYAxis;
break;
case AxisPosition.Bottom:
apos = Plot.PlotArea.Bottom;
perpendicularAxis = Plot.DefaultYAxis;
break;
}
if (axis.PositionAtZeroCrossing)
{
apos = perpendicularAxis.Transform(0);
}
double a0, a1;
if (axis.ShowMinorTicks)
{
GetTickPositions(axis, axis.TickStyle, axis.MinorTickSize, axis.Position, out a0, out a1);
foreach (double value in MinorTickValues)
{
if (value < axis.ActualMinimum || value > axis.ActualMaximum)
{
continue;
}
if (MajorTickValues.Contains(value))
{
continue;
}
double transformedValue = axis.Transform(value);
if (MinorPen != null)
{
if (isHorizontal)
{
rc.DrawLine(transformedValue, Plot.PlotArea.Top, transformedValue, Plot.PlotArea.Bottom, MinorPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, transformedValue, Plot.PlotArea.Right, transformedValue, MinorPen);
}
}
if (isHorizontal)
{
rc.DrawLine(transformedValue, apos + a0, transformedValue, apos + a1, MinorTickPen);
}
else
{
rc.DrawLine(apos + a0, transformedValue, apos + a1, transformedValue, MinorTickPen);
}
}
}
GetTickPositions(axis, axis.TickStyle, axis.MajorTickSize, axis.Position, out a0, out a1);
double maxWidth = 0;
double maxHeight = 0;
foreach (double value in MajorTickValues)
{
if (value < axis.ActualMinimum || value > axis.ActualMaximum)
continue;
double transformedValue = axis.Transform(value);
if (MajorPen != null)
{
if (isHorizontal)
{
rc.DrawLine(transformedValue, Plot.PlotArea.Top, transformedValue, Plot.PlotArea.Bottom, MajorPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, transformedValue, Plot.PlotArea.Right, transformedValue, MajorPen);
}
}
if (isHorizontal)
{
rc.DrawLine(transformedValue, apos + a0, transformedValue, apos + a1, MajorTickPen);
}
else
{
rc.DrawLine(apos + a0, transformedValue, apos + a1, transformedValue, MajorTickPen);
}
if (value == 0 && axis.PositionAtZeroCrossing)
continue;
var pt = new ScreenPoint();
var ha = HorizontalTextAlign.Right;
var va = VerticalTextAlign.Middle;
switch (axis.Position)
{
case AxisPosition.Left:
pt = new ScreenPoint(apos + a1 - TICK_DIST, transformedValue);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Right, VerticalTextAlign.Middle, out ha, out va);
break;
case AxisPosition.Right:
pt = new ScreenPoint(apos + a1 + TICK_DIST, transformedValue);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Left, VerticalTextAlign.Middle, out ha, out va);
break;
case AxisPosition.Top:
pt = new ScreenPoint(transformedValue, apos + a1 - TICK_DIST);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Center, VerticalTextAlign.Bottom, out ha, out va);
break;
case AxisPosition.Bottom:
pt = new ScreenPoint(transformedValue, apos + a1 + TICK_DIST);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Center, VerticalTextAlign.Top, out ha, out va);
break;
}
string text = axis.FormatValue(value);
var size = rc.DrawMathText(pt, text, Plot.TextColor,
axis.FontFamily, axis.FontSize, axis.FontWeight,
axis.Angle, ha, va);
maxWidth = Math.Max(maxWidth, size.Width);
maxHeight = Math.Max(maxHeight, size.Height);
}
if (axis.PositionAtZeroCrossing)
{
double t0 = axis.Transform(0);
if (isHorizontal)
{
rc.DrawLine(t0, Plot.PlotArea.Top, t0, Plot.PlotArea.Bottom, ZeroPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, t0, Plot.PlotArea.Right, t0, ZeroPen);
}
}
if (axis.ExtraGridlines != null)
{
foreach (double value in axis.ExtraGridlines)
{
if (!IsWithin(value, axis.ActualMinimum, axis.ActualMaximum))
continue;
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
rc.DrawLine(transformedValue, Plot.PlotArea.Top, transformedValue, Plot.PlotArea.Bottom, ExtraPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, transformedValue, Plot.PlotArea.Right, transformedValue, ExtraPen);
}
}
}
if (isHorizontal)
{
rc.DrawLine(Plot.PlotArea.Left, apos, Plot.PlotArea.Right, apos, MajorPen);
}
else
{
rc.DrawLine(apos, Plot.PlotArea.Top, apos, Plot.PlotArea.Bottom, MajorPen);
}
if (!String.IsNullOrWhiteSpace(axis.Title))
{
// Axis legend
double ymid = axis.Transform((axis.ActualMinimum + axis.ActualMaximum) / 2);
double angle = -90;
var lpt = new ScreenPoint();
var halign = HorizontalTextAlign.Center;
var valign = VerticalTextAlign.Top;
if (axis.PositionAtZeroCrossing)
{
ymid = perpendicularAxis.Transform(perpendicularAxis.ActualMaximum);
// valign = axis.IsReversed ? VerticalTextAlign.Top : VerticalTextAlign.Bottom;
}
switch (axis.Position)
{
case AxisPosition.Left:
lpt = new ScreenPoint(AXIS_LEGEND_DIST, ymid);
break;
case AxisPosition.Right:
lpt = new ScreenPoint(rc.Width - AXIS_LEGEND_DIST, ymid);
valign = VerticalTextAlign.Bottom;
break;
case AxisPosition.Top:
lpt = new ScreenPoint(ymid, AXIS_LEGEND_DIST);
halign = HorizontalTextAlign.Center;
valign = VerticalTextAlign.Top;
angle = 0;
break;
case AxisPosition.Bottom:
lpt = new ScreenPoint(ymid, rc.Height - AXIS_LEGEND_DIST);
halign = HorizontalTextAlign.Center;
valign = VerticalTextAlign.Bottom;
angle = 0;
break;
}
rc.DrawText(lpt, axis.Title, Plot.TextColor,
axis.FontFamily, axis.FontSize, axis.FontWeight,
angle, halign, valign);
}
}
/// <summary>
/// Gets the nearest point.
/// </summary>
/// <param name="point">
/// The point.
/// </param>
/// <param name="interpolate">
/// interpolate if set to <c>true</c> .
/// </param>
/// <returns>
/// A TrackerHitResult for the current hit.
/// </returns>
public override TrackerHitResult GetNearestPoint(ScreenPoint point, bool interpolate)
{
if (this.XAxis == null || this.YAxis == null)
{
return(null);
}
if (interpolate)
{
return(null);
}
TrackerHitResult result = null;
double minimumDistance = double.MaxValue;
int i = 0;
var xaxisTitle = this.XAxis.Title ?? "X";
var yaxisTitle = this.YAxis.Title ?? "Y";
var colorAxisTitle = (this.ColorAxis != null ? this.ColorAxis.Title : null) ?? "Z";
var formatString = TrackerFormatString;
if (string.IsNullOrEmpty(this.TrackerFormatString))
{
// Create a default format string
formatString = "{1}: {2}\n{3}: {4}";
if (this.ColorAxis != null)
{
formatString += "\n{5}: {6}";
}
}
foreach (var p in this.Points)
{
if (this.XAxis == null || this.YAxis == null || p.X < this.XAxis.ActualMinimum || p.X > this.XAxis.ActualMaximum || p.Y < this.YAxis.ActualMinimum ||
p.Y > this.YAxis.ActualMaximum)
{
i++;
continue;
}
var dp = new DataPoint(p.X, p.Y);
var sp = Axis.Transform(dp, this.XAxis, this.YAxis);
double dx = sp.x - point.x;
double dy = sp.y - point.y;
double d2 = (dx * dx) + (dy * dy);
if (d2 < minimumDistance)
{
var item = this.GetItem(i);
result = new TrackerHitResult(this, dp, sp, item);
object xvalue = this.XAxis != null?this.XAxis.GetValue(dp.X) : dp.X;
object yvalue = this.YAxis != null?this.YAxis.GetValue(dp.Y) : dp.Y;
object zvalue = null;
var scatterPoint = p as ScatterPoint;
if (scatterPoint != null)
{
if (!double.IsNaN(scatterPoint.Value) && !double.IsInfinity(scatterPoint.Value))
{
zvalue = scatterPoint.Value;
}
}
result.Text = StringHelper.Format(
this.ActualCulture,
formatString,
item,
this.Title,
xaxisTitle,
xvalue,
yaxisTitle,
yvalue,
colorAxisTitle,
zvalue);
minimumDistance = d2;
}
i++;
}
return(result);
}
public override void Render(Axis axis)
{
base.Render(axis);
var perpendicularAxis = Plot.DefaultXAxis;
bool isHorizontal = true;
// Axis position (x or y screen coordinate)
double apos = 0;
switch (axis.Position)
{
case AxisPosition.Left:
apos = Plot.PlotArea.Left;
isHorizontal = false;
break;
case AxisPosition.Right:
apos = Plot.PlotArea.Right;
isHorizontal = false;
break;
case AxisPosition.Top:
apos = Plot.PlotArea.Top;
perpendicularAxis = Plot.DefaultYAxis;
break;
case AxisPosition.Bottom:
apos = Plot.PlotArea.Bottom;
perpendicularAxis = Plot.DefaultYAxis;
break;
}
if (axis.PositionAtZeroCrossing)
{
apos = perpendicularAxis.Transform(0);
}
double a0, a1;
if (axis.ShowMinorTicks)
{
GetTickPositions(axis, axis.TickStyle, axis.MinorTickSize, axis.Position, out a0, out a1);
foreach (double value in MinorTickValues)
{
if (value < axis.ActualMinimum || value > axis.ActualMaximum)
{
continue;
}
if (MajorTickValues.Contains(value))
{
continue;
}
double transformedValue = axis.Transform(value);
if (MinorPen != null)
{
if (isHorizontal)
{
rc.DrawLine(transformedValue, Plot.PlotArea.Top, transformedValue, Plot.PlotArea.Bottom, MinorPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, transformedValue, Plot.PlotArea.Right, transformedValue, MinorPen);
}
}
if (isHorizontal)
{
rc.DrawLine(transformedValue, apos + a0, transformedValue, apos + a1, MinorTickPen);
}
else
{
rc.DrawLine(apos + a0, transformedValue, apos + a1, transformedValue, MinorTickPen);
}
}
}
GetTickPositions(axis, axis.TickStyle, axis.MajorTickSize, axis.Position, out a0, out a1);
double maxWidth = 0;
double maxHeight = 0;
foreach (double value in MajorTickValues)
{
if (value < axis.ActualMinimum || value > axis.ActualMaximum)
{
continue;
}
double transformedValue = axis.Transform(value);
if (MajorPen != null)
{
if (isHorizontal)
{
rc.DrawLine(transformedValue, Plot.PlotArea.Top, transformedValue, Plot.PlotArea.Bottom, MajorPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, transformedValue, Plot.PlotArea.Right, transformedValue, MajorPen);
}
}
if (isHorizontal)
{
rc.DrawLine(transformedValue, apos + a0, transformedValue, apos + a1, MajorTickPen);
}
else
{
rc.DrawLine(apos + a0, transformedValue, apos + a1, transformedValue, MajorTickPen);
}
if (value == 0 && axis.PositionAtZeroCrossing)
{
continue;
}
var pt = new ScreenPoint();
var ha = HorizontalTextAlign.Right;
var va = VerticalTextAlign.Middle;
switch (axis.Position)
{
case AxisPosition.Left:
pt = new ScreenPoint(apos + a1 - TICK_DIST, transformedValue);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Right, VerticalTextAlign.Middle, out ha, out va);
break;
case AxisPosition.Right:
pt = new ScreenPoint(apos + a1 + TICK_DIST, transformedValue);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Left, VerticalTextAlign.Middle, out ha, out va);
break;
case AxisPosition.Top:
pt = new ScreenPoint(transformedValue, apos + a1 - TICK_DIST);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Center, VerticalTextAlign.Bottom, out ha, out va);
break;
case AxisPosition.Bottom:
pt = new ScreenPoint(transformedValue, apos + a1 + TICK_DIST);
GetRotatedAlignments(axis.Angle, HorizontalTextAlign.Center, VerticalTextAlign.Top, out ha, out va);
break;
}
string text = axis.FormatValue(value);
var size = rc.DrawMathText(pt, text, Plot.TextColor,
axis.FontFamily, axis.FontSize, axis.FontWeight,
axis.Angle, ha, va);
maxWidth = Math.Max(maxWidth, size.Width);
maxHeight = Math.Max(maxHeight, size.Height);
}
if (axis.PositionAtZeroCrossing)
{
double t0 = axis.Transform(0);
if (isHorizontal)
{
rc.DrawLine(t0, Plot.PlotArea.Top, t0, Plot.PlotArea.Bottom, ZeroPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, t0, Plot.PlotArea.Right, t0, ZeroPen);
}
}
if (axis.ExtraGridlines != null)
{
foreach (double value in axis.ExtraGridlines)
{
if (!IsWithin(value, axis.ActualMinimum, axis.ActualMaximum))
{
continue;
}
double transformedValue = axis.Transform(value);
if (isHorizontal)
{
rc.DrawLine(transformedValue, Plot.PlotArea.Top, transformedValue, Plot.PlotArea.Bottom, ExtraPen);
}
else
{
rc.DrawLine(Plot.PlotArea.Left, transformedValue, Plot.PlotArea.Right, transformedValue, ExtraPen);
}
}
}
if (isHorizontal)
{
rc.DrawLine(Plot.PlotArea.Left, apos, Plot.PlotArea.Right, apos, MajorPen);
}
else
{
rc.DrawLine(apos, Plot.PlotArea.Top, apos, Plot.PlotArea.Bottom, MajorPen);
}
if (!String.IsNullOrWhiteSpace(axis.Title))
{
// Axis legend
double ymid = axis.Transform((axis.ActualMinimum + axis.ActualMaximum) / 2);
double angle = -90;
var lpt = new ScreenPoint();
var halign = HorizontalTextAlign.Center;
var valign = VerticalTextAlign.Top;
if (axis.PositionAtZeroCrossing)
{
ymid = perpendicularAxis.Transform(perpendicularAxis.ActualMaximum);
// valign = axis.IsReversed ? VerticalTextAlign.Top : VerticalTextAlign.Bottom;
}
switch (axis.Position)
{
case AxisPosition.Left:
lpt = new ScreenPoint(AXIS_LEGEND_DIST, ymid);
break;
case AxisPosition.Right:
lpt = new ScreenPoint(rc.Width - AXIS_LEGEND_DIST, ymid);
valign = VerticalTextAlign.Bottom;
break;
case AxisPosition.Top:
lpt = new ScreenPoint(ymid, AXIS_LEGEND_DIST);
halign = HorizontalTextAlign.Center;
valign = VerticalTextAlign.Top;
angle = 0;
break;
case AxisPosition.Bottom:
lpt = new ScreenPoint(ymid, rc.Height - AXIS_LEGEND_DIST);
halign = HorizontalTextAlign.Center;
valign = VerticalTextAlign.Bottom;
angle = 0;
break;
}
rc.DrawText(lpt, axis.Title, Plot.TextColor,
axis.FontFamily, axis.FontSize, axis.FontWeight,
angle, halign, valign);
}
}
