private IDataSeries <double, double> GenerateDataSeries(AxisAlignment axisAlignment, int index)
{
var dataSeries = new XyDataSeries <double, double>();
dataSeries.SeriesName = string.Format("Series {0}", index);
double gradient = axisAlignment == AxisAlignment.Right ? index : -index;
double start = axisAlignment == AxisAlignment.Right ? 0.0 : 14000;
DoubleSeries straightLineData = DataManager.Instance.GetStraightLine(gradient, start, SeriesPointCount);
dataSeries.Append(straightLineData.XData, straightLineData.YData);
return(dataSeries);
}
private IAxis GenerateLinearAxis(AxisAlignment axisAlignment)
{
return(new NumericAxis
{
AxisAlignment = axisAlignment,
TextFormatting = "#.#E+0",
ScientificNotation = ScientificNotation.Normalized,
GrowBy = new DoubleRange(0.1, 0.1),
DrawMajorBands = false
});
}
private static IDataSeries GenerateDataSeries(AxisAlignment alignment, int index)
{
var dataSeries = new XyDataSeries <double, double> {
SeriesName = $"Series {index}"
};
var gradient = alignment == AxisAlignment.Right ? index : -index;
var start = alignment == AxisAlignment.Right ? 0d : 14000d;
var straightLine = DataManager.Instance.GetStraightLine(gradient, start, SeriesPointCount);
dataSeries.Append(straightLine.XData, straightLine.YData);
return(dataSeries);
}
public static Charting.Visuals.Axes.AxisAlignment FromXfAxisAlignment(AxisAlignment xfAxisAlignment)
{
switch (xfAxisAlignment)
{
case AxisAlignment.Left: return(Charting.Visuals.Axes.AxisAlignment.Left);
case AxisAlignment.Bottom: return(Charting.Visuals.Axes.AxisAlignment.Bottom);
case AxisAlignment.Right: return(Charting.Visuals.Axes.AxisAlignment.Right);
case AxisAlignment.Top: return(Charting.Visuals.Axes.AxisAlignment.Top);
case AxisAlignment.Default: return(Charting.Visuals.Axes.AxisAlignment.Auto);
default:
throw new NotImplementedException("The AxisAlignment " + xfAxisAlignment.ToString() +
" has not been handled");
}
}
internal static WpfAxisAlignment FromXfAxisAlignment(AxisAlignment xfAxisAlignment)
{
switch (xfAxisAlignment)
{
case AxisAlignment.Left: return(WpfAxisAlignment.Left);
case AxisAlignment.Bottom: return(WpfAxisAlignment.Bottom);
case AxisAlignment.Right: return(WpfAxisAlignment.Right);
case AxisAlignment.Top: return(WpfAxisAlignment.Top);
case AxisAlignment.Default: return(WpfAxisAlignment.Default);
default:
throw new NotImplementedException("The AxisAlignment " + xfAxisAlignment.ToString() +
" has not been handled");
}
}
public void SeriesSelectionExampleView_OnLoaded(object sender, RoutedEventArgs e)
{
// Create a number of DataSeries of type X=double, Y=double
var allDataSeries = new IDataSeries <double, double> [SeriesCount];
var initialColor = Colors.Blue;
// Suspend visual updates while we add N RenderableSeries
using (sciChartSurface.SuspendUpdates())
{
// Add N data and renderable series
for (int i = 0; i < SeriesCount; i++)
{
AxisAlignment alignment = i % 2 == 0 ? AxisAlignment.Left : AxisAlignment.Right;
allDataSeries[i] = GenerateDataSeries(alignment, i);
var renderableSeries = new FastLineRenderableSeries {
Stroke = initialColor
};
renderableSeries.YAxisId = alignment.ToString();
// Assign DataSeries to RenderableSeries
renderableSeries.DataSeries = allDataSeries[i];
// Assign RenderableSeries to SciChartSurface
sciChartSurface.RenderableSeries.Add(renderableSeries);
// Colors are incremented for visual purposes only
int newR = initialColor.R == 255 ? 255 : initialColor.R + 5;
int newB = initialColor.B == 0 ? 0 : initialColor.B - 2;
initialColor = Color.FromArgb(255, (byte)newR, initialColor.G, (byte)newB);
}
}
sciChartSurface.ZoomExtents();
}
private IAxis GenerateLogarithmicAxis(AxisAlignment axisAlignment, bool withNegativeScale)
{
var axis = withNegativeScale ? new NegativeLogarithmicAxis() : new LogarithmicNumericAxis();
axis.AxisAlignment = axisAlignment;
axis.TextFormatting = "#.#E+0";
axis.ScientificNotation = ScientificNotation.LogarithmicBase;
axis.GrowBy = new DoubleRange(0.1, 0.1);
axis.DrawMajorBands = false;
var converter = new LogarithmicBaseConverter();
var logBinding = new Binding("SelectedValue")
{
ElementName = "logBasesChbx", Converter = converter
};
axis.SetBinding(LogarithmicNumericAxis.LogarithmicBaseProperty, logBinding);
return(axis);
}
protected override Size ArrangeOverride(Size finalSize)
{
// Position children.
foreach (UIElement child in Children)
{
// Add translate transform.
var translate = child.RenderTransform as TranslateTransform;
if (translate == null)
{
translate = new TranslateTransform();
child.RenderTransform = translate;
}
// Get positioning information.
ValueSource xSource = DependencyPropertyHelper.GetValueSource(child, XProperty);
object x = xSource.BaseValueSource == BaseValueSource.Default ? null : child.GetValue(XProperty);
ValueSource ySource = DependencyPropertyHelper.GetValueSource(child, YProperty);
object y = ySource.BaseValueSource == BaseValueSource.Default ? null : child.GetValue(YProperty);
AxisAlignment alignmentX = (AxisAlignment)child.GetValue(AlignmentXProperty);
AxisAlignment alignmentY = (AxisAlignment)child.GetValue(AlignmentYProperty);
// Position.
if (x != null)
{
translate.X = PositionInInterval(VisibleIntervalX, finalSize.Width, child.DesiredSize.Width, (TX)x, alignmentX);
}
if (y != null)
{
translate.Y = PositionInInterval(VisibleIntervalY, finalSize.Height, child.DesiredSize.Height, (TY)y, alignmentY);
}
// Arrange.
child.Arrange(new Rect(new Point(0, 0), child.DesiredSize));
}
return(finalSize);
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value == null)
{
return(value);
}
AxisInfo axis = (AxisInfo)value;
AxisAlignment aligment = axis.AxisAlignment;
if (aligment == AxisAlignment.Right)
{
return(axis.AxisFormattedDataValue);
}
else if (aligment == AxisAlignment.Left)
{
return(axis.AxisFormattedDataValue);
}
Type type = axis.DataValue.GetType();
if (type.Name.Equals("DateTime"))
{
DateTime t = (DateTime)axis.DataValue;
String formatedT = string.Format("{0:yyyy-MM-dd HH:mm}", t).ToString();
return(formatedT);
}
else if (type.Name.Equals("Double"))
{
Double t = (Double)axis.DataValue;
Double formatedT = ((int)(t * 10000)) / 10000.0;
return(formatedT);
}
return(axis.DataValue);
}
public void SetAxisAlignment(AxisAlignment mode)
{
PrevalidateModel();
_model.AxisAlignment = mode;
}
/// <summary>
/// Constructor for an a structure
/// </summary>
/// <param name="x">Alignment for the _x a</param>
/// <param name="y">Alignment for the _y a</param>
/// <param name="z">Alignment for the _z a</param>
/// <exception cref="ArgumentException">
/// Thrown if two or more a share or complement over an alignment.
/// </exception>
public Axis(AxisAlignment x, AxisAlignment y, AxisAlignment z)
{
bool ud = false, lr = false, nf = false, fail = false;
if (x == AxisAlignment.UP || x == AxisAlignment.DOWN)
{
ud = true;
}
if (x == AxisAlignment.LEFT || x == AxisAlignment.RIGHT)
{
lr = true;
}
if (x == AxisAlignment.NEAR || x == AxisAlignment.FAR)
{
nf = true;
}
if (y == AxisAlignment.UP || y == AxisAlignment.DOWN)
{
ud = ud ? (fail = true): true;
}
if (y == AxisAlignment.LEFT || y == AxisAlignment.RIGHT)
{
lr = lr ? (fail = true): true;
}
if (y == AxisAlignment.NEAR || y == AxisAlignment.FAR)
{
nf = nf ? (fail = true): true;
}
if (z == AxisAlignment.UP || z == AxisAlignment.DOWN)
{
if (ud)
{
fail = true;
}
}
if (z == AxisAlignment.LEFT || z == AxisAlignment.RIGHT)
{
if (lr)
{
fail = true;
}
}
if (z == AxisAlignment.NEAR || z == AxisAlignment.FAR)
{
if (nf)
{
fail = true;
}
}
if (fail)
{
throw new ArgumentException(AXIS_DUPLICATION);
}
this.x = x;
this.y = y;
this.z = z;
}
public void Map
(
out float x, out float y,
out float z, float right, float up, float far,
out bool iRight, out bool iUp, out bool iFar
)
{
// Preinitialisation
x = 0.0f; y = 0.0f; z = 0.0f;
iRight = false; iUp = false; iFar = false;
switch (X)
{
case AxisAlignment.DOWN: x = up; iUp = true; break;
case AxisAlignment.UP: x = up; break;
case AxisAlignment.RIGHT: x = right; break;
case AxisAlignment.LEFT: x = right; iRight = true; break;
case AxisAlignment.NEAR: x = far; iFar = true; break;
case AxisAlignment.FAR: x = far; break;
default: throw new ArgumentException(); // Should never reach this
}
switch (Y)
{
case AxisAlignment.DOWN: y = up; iUp = true; break;
case AxisAlignment.UP: y = up; break;
case AxisAlignment.RIGHT: y = right; break;
case AxisAlignment.LEFT: y = right; iRight = true; break;
case AxisAlignment.NEAR: y = far; iFar = true; break;
case AxisAlignment.FAR: y = far; break;
default: throw new ArgumentException(); // Should never reach this
}
switch (Z)
{
case AxisAlignment.DOWN: z = up; iUp = true; break;
case AxisAlignment.UP: z = up; break;
case AxisAlignment.RIGHT: z = right; break;
case AxisAlignment.LEFT: z = right; iRight = true; break;
case AxisAlignment.NEAR: z = far; iFar = true; break;
case AxisAlignment.FAR: z = far; break;
default: throw new ArgumentException(); // Should never reach this
}
}
private void Initialize(UlDoubleBufferedSeriesCollection series)
{
zoomAxisCombo.SelectedIndex = 0;
viewGraph.Series.Clear();
viewGraph.Mode = EChartMode.Dynamic;
viewGraph.BackColor = Color.White;
viewGraph.LegendFont = new Font("Arial", 7, FontStyle.Regular);
viewGraph.SetBufferedSeries(series);
viewGraph.SetPrimaryAxisX(AxisAlignment.Near, "Time", StringAlignment.Center, 0, 60000);
InitializeYAxes();
LoadYAxes();
foreach (YAxisRow row in YAxisRows)
{
AxisAlignment align = (row.Align == EAxisAlign.Left) ? AxisAlignment.Near : AxisAlignment.Far;
if (row.AxisNo == 0)
{
viewGraph.SetPrimaryAxisY(align, row.DescriptionUnit, StringAlignment.Far, row.WholeMin, row.WholeMax);
}
else
{
viewGraph.AddSecondaryAxisY(align, row.DescriptionUnit, StringAlignment.Far, row.WholeMin, row.WholeMax);
}
}
InitializePlotSeries();
LoadPlotSeries();
xAxis = new XAxisRow();
LoadXAxis();
ResetRangeAxisX();
viewGraph.Prepare();
viewGraph.SetGridLinesAxisX(true);
viewGraph.SetGridLinesAxisY(true);
foreach (SeriesRow row in PlotSeriesRows)
{
viewGraph.Series[row.Name].View.Color = row.Color;
viewGraph.Series[row.Name].Visible = row.Checked;
viewGraph.SetSeriesAxisY(row.Name, GetIndexAxisY(row.UnitType));
}
foreach (YAxisRow row in YAxisRows)
{
viewGraph.AxesY[row.AxisNo].Visibility =
(row.Checked == true) ? DefaultBoolean.True : DefaultBoolean.False;
}
viewGraph.MarkLine.ShowValueMarkPoint += DoShowValueMarkPoint;
viewGraph.MarkLine.Visible = false;
viewGraph.Zooming.ZoomStackChanged += DoZoomStackChanged;
viewGraph.Zooming.Clear();
graphPauseLed.Active = false;
plotSeriesGrid.DataSource = PlotSeriesRows;
plotSeriesGrid.UseDirectXPaint = DefaultBoolean.False;
plotSeriesGridView.Columns["Checked"].ImageOptions.ImageIndex = 1;
plotSeriesGridView.Appearance.EvenRow.BackColor = Color.FromArgb(244, 244, 236);
plotSeriesGridView.OptionsView.EnableAppearanceEvenRow = true;
SetCursorAColumnVisible(false);
SetCursorBColumnVisible(false);
plotSeriesGridView.RefreshData();
}
double PositionInInterval <T, TSize>(Interval <T, TSize> interval, double panelSize, double elementSize, T value, AxisAlignment alignment)
where T : IComparable <T>
where TSize : IComparable <TSize>
{
double percentage = interval.GetPercentageFor(value);
double position = percentage * panelSize;
switch (alignment)
{
case AxisAlignment.AfterValue:
return(interval.IsReversed ? position - elementSize : position);
case AxisAlignment.Center:
return(position - (elementSize / 2));
case AxisAlignment.BeforeValue:
return(interval.IsReversed ? position : position - elementSize);
default:
throw new NotSupportedException(alignment + " is not supported by the AxesPanel.");
}
}
public static void SetAlignmentY(FrameworkElement element, AxisAlignment value)
{
element.SetValue(AlignmentYProperty, value);
}
public OrthogonalAxis(AxisAlignment x, AxisAlignment y, AxisAlignment z)
{
const Vector vx = new Vector(1, 0, 0);
const Vector vMx = new Vector(-1, 0, 0);
switch (x)
{
case AxisAlignment.FORWARD:
Forward = vx;
break;
case AxisAlignment.BACKWARD:
Forward = vMx;
break;
case AxisAlignment.UP:
Up = vx;
break;
case AxisAlignment.DOWN:
Up = vMx;
break;
case AxisAlignment.RIGHT:
Right = vx;
break;
case AxisAlignment.LEFT:
Right = vMx;
break;
}
const Vector vy = new Vector(0, 1, 0);
const Vector vMy = new Vector(0, -1, 0);
switch (y)
{
case AxisAlignment.FORWARD:
Forward = vy;
break;
case AxisAlignment.BACKWARD:
Forward = vMy;
break;
case AxisAlignment.UP:
Up = vy;
break;
case AxisAlignment.DOWN:
Up = vMy;
break;
case AxisAlignment.RIGHT:
Right = vy;
break;
case AxisAlignment.LEFT:
Right = vMy;
break;
}
const Vector vz = new Vector(0, 0, 1);
const Vector vMz = new Vector(0, 0, -1);
switch (z)
{
case AxisAlignment.FORWARD:
Forward = vz;
break;
case AxisAlignment.BACKWARD:
Forward = vMz;
break;
case AxisAlignment.UP:
Up = vz;
break;
case AxisAlignment.DOWN:
Up = vMz;
break;
case AxisAlignment.RIGHT:
Right = vz;
break;
case AxisAlignment.LEFT:
Right = vMz;
break;
}
if
(
Vector.Angle(_right, _up) != Angle.Right_Angle ||
Vector.Angle(_up, _forward) != Angle.Right_Angle ||
Vector.Angle(_right, _forward) != Angle.Right_Angle
)
{
throw new ArgumentException("The vectors provided are not orthogonal.");
}
}
