/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
/// <param name="unit">Unit of the serier</param>
public Series(string name, SeriesType type = SeriesType.Line, string unit = "$")
{
Name = name;
Values = new List <ChartPoint>();
SeriesType = type;
Unit = unit;
}
internal static string GetXmlRepresentation(this SeriesType seriesType)
{
switch (seriesType)
{
case SeriesType.Int32:
{
return("Int32");
}
case SeriesType.Int64:
{
return("Int64");
}
case SeriesType.Float32:
{
return("Float32");
}
case SeriesType.Float64:
{
return("Float64");
}
case SeriesType.String:
{
return("String");
}
case SeriesType.Boolean:
{
return("Boolean");
}
case SeriesType.DateTime:
{
return("DateTime");
}
case SeriesType.EmbeddedXML:
{
return("EmbeddedXML");
}
case SeriesType.PNG:
{
return("PNG");
}
case SeriesType.SVG:
{
return("SVG");
}
default:
{
throw new ArgumentException("Specified SeriesType value is not valid.");
}
}
}
/// <summary>
/// Returns a market series specific data series based on provided series type
/// </summary>
/// <param name="marketSeries">The market series</param>
/// <param name="seriesType">Series type</param>
/// <returns>DataSeries</returns>
public static DataSeries GetSeries(this MarketSeries marketSeries, SeriesType seriesType)
{
switch (seriesType)
{
case SeriesType.Open:
return(marketSeries.Open);
case SeriesType.High:
return(marketSeries.High);
case SeriesType.Low:
return(marketSeries.Low);
case SeriesType.Close:
return(marketSeries.Close);
case SeriesType.Median:
return(marketSeries.Median);
case SeriesType.TickVolume:
return(marketSeries.TickVolume);
case SeriesType.Typical:
return(marketSeries.Typical);
case SeriesType.WeightedClose:
return(marketSeries.WeightedClose);
default:
return(null);
}
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="seriesIndex">Type of chart we should create if it doesn't already exist.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="value">Value for the chart sample.</param>
/// <param name="unit">Unit for the sample axis</param>
/// <remarks>Sample can be used to create new charts or sample equity - daily performance.</remarks>
public void Sample(string chartName, string seriesName, int seriesIndex, SeriesType seriesType, DateTime time, decimal value, string unit = "$")
{
// Sampling during warming up period skews statistics
if (Algorithm.IsWarmingUp)
{
return;
}
lock (_chartLock)
{
//Add a copy locally:
if (!Charts.ContainsKey(chartName))
{
Charts.AddOrUpdate(chartName, new Chart(chartName));
}
//Add the sample to our chart:
if (!Charts[chartName].Series.ContainsKey(seriesName))
{
Charts[chartName].Series.Add(seriesName, new Series(seriesName, seriesType, seriesIndex, unit));
}
//Add our value:
Charts[chartName].Series[seriesName].Values.Add(new ChartPoint(time, value));
}
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="chartType">Type of chart we should create if it doesn't already exist.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="value">Value for the chart sample.</param>
/// <param name="unit">Unit for the sample axis</param>
/// <remarks>Sample can be used to create new charts or sample equity - daily performance.</remarks>
public void Sample(string chartName, ChartType chartType, string seriesName, SeriesType seriesType, DateTime time, decimal value, string unit = "$")
{
var chartFilename = Path.Combine(_chartDirectory, chartName + "-" + seriesName + ".csv");
lock (_chartLock)
{
// Add line to list in dictionary, will be written to file at the end
List <string> rows;
if (!_equityResults.TryGetValue(chartFilename, out rows))
{
rows = new List <string>();
_equityResults[chartFilename] = rows;
}
rows.Add(time + "," + value.ToString("F2", CultureInfo.InvariantCulture));
//Add a copy locally:
if (!Charts.ContainsKey(chartName))
{
Charts.AddOrUpdate <string, Chart>(chartName, new Chart(chartName, chartType));
}
//Add the sample to our chart:
if (!Charts[chartName].Series.ContainsKey(seriesName))
{
Charts[chartName].Series.Add(seriesName, new Series(seriesName, seriesType));
}
//Add our value:
Charts[chartName].Series[seriesName].Values.Add(new ChartPoint(time, value));
}
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesIndex">Series chart index - which chart should this series belong</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="value">Value for the chart sample.</param>
/// <param name="unit">Unit for the chart axis</param>
/// <remarks>Sample can be used to create new charts or sample equity - daily performance.</remarks>
protected abstract void Sample(string chartName,
string seriesName,
int seriesIndex,
SeriesType seriesType,
DateTime time,
decimal value,
string unit = "$");
public void TrendChart()
{
//DashboardInitialize();
AddWidget("Trend Chart");
Options("Metric").Clicks();
CustomMetric();
Options("Axis").Clicks();
AxisType.SelectDropdown("Month");
SeriesSelection.SelectDropdown("Resources");
SeriesType.SelectDropdown("Departments");
Characterlimit.ClearText(); Characterlimit.EnterText("10");
Options("Base").Clicks();
BasenGoal(.5, 1.5);
Filter("Trend Chart");
Apply(); WaitforIt(Properties.InactivePhase);
}
public void HeatMap()
{
//DashboardInitialize();
AddWidget("HeatMap");
Options("Metric").Clicks();
RatioMetric();
Options("Axis").Clicks();
AxisType.SelectDropdown("Day");
SeriesSelection.SelectDropdown("Resources");
SeriesType.SelectDropdown("Departments");
Characterlimit.ClearText(); Characterlimit.EnterText("10");
Options("Formatting").Clicks();
Formatting();
Filter("Heatmap");
Apply();
}
public virtual void MouseUp(MouseControllerEventArgs e)
{
Internalmovdir = MoveDir;
BackUpCellValues.Clear();
CellData = new GridCellData();
for (int Row = Gridmodel.SelectedCells.Top; Row <= Gridmodel.SelectedCells.Bottom; Row++)
{
for (int Column = this.SelectedRange.Left; Column <= this.SelectedRange.Right; Column++)
{
var CellRowColumnIndex = new RowColumnIndex(Row, Column);
GridStyleInfoStore styleinfostore = (GridStyleInfoStore)this.grid.Model[Row, Column].Store.Clone();
//this.CellData[this.grid.Model[Row, Column].CellRowColumnIndex] = styleinfostore;
BackUpCellValues.Add(CellRowColumnIndex, styleinfostore);//this.CellData[this.grid.Model[Row, Column].CellRowColumnIndex]);
}
}
this.InnerFillType = SeriesType.FillSeries;
this.FillData();
MoveDir = MovingDirection.None;
IsMouseDown = false;
#if !SILVERLIGHT
if (Buttonside == MouseButton.Left)
#else
if (Buttonside == MouseButtons.Left)
#endif
{
OpenFilterDropDown();
}
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="seriesIndex">Type of chart we should create if it doesn't already exist.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="unit">Unit of the sample</param>
/// <param name="value">Value for the chart sample.</param>
public void Sample(string chartName, string seriesName, int seriesIndex, SeriesType seriesType, DateTime time, decimal value, string unit = "$")
{
// Sampling during warming up period skews statistics
if (Algorithm.IsWarmingUp)
{
return;
}
lock (_chartLock)
{
//Add a copy locally:
Chart chart;
if (!Charts.TryGetValue(chartName, out chart))
{
chart = new Chart(chartName);
Charts.AddOrUpdate(chartName, chart);
}
//Add the sample to our chart:
Series series;
if (!chart.Series.TryGetValue(seriesName, out series))
{
series = new Series(seriesName, seriesType, seriesIndex, unit);
chart.Series.Add(seriesName, series);
}
//Add our value:
if (series.Values.Count == 0 || time > Time.UnixTimeStampToDateTime(series.Values[series.Values.Count - 1].x))
{
series.Values.Add(new ChartPoint(time, value));
}
}
}
public SeriesModel(string name, SeriesType type, List <double> x, List <double> y, string color)
{
Name = name;
Type = type;
X = x;
Y = y;
Color = color;
}
public SeriesModel(string name, SeriesType type, double x, double y, string color)
{
Name = name;
Type = type;
X = new List <double>(new double[] { x });
Y = new List <double>(new double[] { y });
Color = color;
}
private static T ChooseValue <T>(SeriesType seriesType, T expectedValue, T actualValue, T failValue)
{
if (seriesType == SeriesType.Actual)
{
return(actualValue);
}
return(seriesType == SeriesType.Expected ? expectedValue : failValue);
}
public double GetSeriesMovingAverageValue(
Bars bars, SeriesType seriesType, int periods, MovingAverageType type, int index)
{
var series = bars.GetSeries(seriesType);
var ma = _algo.Indicators.MovingAverage(series, periods, type);
return(ma.Result[index]);
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
public Series(string name, SeriesType type)
{
Name = name;
SeriesType = type;
Index = 0;
Unit = "$";
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.None;
}
/// <summary>
/// Gets the drawing class for this series or indicator.
/// </summary>
/// <param name="seriesType"></param>
/// <param name="indicatorType"></param>
/// <returns></returns>
public static IChartDrawing GetChartDrawing(SeriesType seriesType, IndicatorType? indicatorType)
{
switch (seriesType)
{
case SeriesType.LineChart: return new LineChart();
}
throw new ArgumentException("No IChartDrawing found for this SeriesType and IndicatorType combination.");
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
public Series(string name)
{
Name = name;
SeriesType = SeriesType.Line;
Unit = "$";
Index = 0;
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.None;
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
/// <param name="index">Index position on the chart of the series</param>
/// <param name="unit">Unit for the series axis</param>
public Series(string name, SeriesType type, int index, string unit)
{
Name = name;
SeriesType = type;
Index = index;
Unit = unit;
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.None;
}
/// <summary>
/// Gets the drawing class for this series or indicator.
/// </summary>
/// <param name="seriesType"></param>
/// <param name="indicatorType"></param>
/// <returns></returns>
public static IChartDrawing GetChartDrawing(SeriesType seriesType, IndicatorType?indicatorType)
{
switch (seriesType)
{
case SeriesType.LineChart: return(new LineChart());
}
throw new ArgumentException("No IChartDrawing found for this SeriesType and IndicatorType combination.");
}
/// <summary>Series type has been changed by the user.</summary>
/// <param name="sender">Event sender</param>
/// <param name="e">Event arguments</param>
void OnSeriesTypeChanged(object sender, EventArgs e)
{
SeriesType seriesType = (SeriesType)Enum.Parse(typeof(SeriesType), this.seriesView.SeriesType.SelectedValue);
this.SetModelProperty("Type", seriesType);
/// This doesn't quite work yet. If the previous series was a scatter plot, there is no x2, y2 to work with
/// and things go a bit awry.
/// this.seriesView.ShowX2Y2(series.Type == SeriesType.Area);
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
/// <param name="index">Index position on the chart of the series</param>
public Series(string name, SeriesType type, int index)
{
Name = name;
SeriesType = type;
Index = index;
Unit = "$";
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.Circle;
}
public double GetSeriesMovingAverageValue(
MarketSeries marketSeries, SeriesType seriesType, int periods, MovingAverageType type, int index)
{
DataSeries series = marketSeries.GetSeries(seriesType);
MovingAverage ma = _algo.Indicators.MovingAverage(series, periods, type);
return(ma.Result[index]);
}
public SeriesBuilder WithIndividualValueSet(SeriesType seriesType, IEnumerable <dynamic> values, int startIndex, int endIndex)
{
this.series.ValueSets.Add(
new IndividualValueSetBuilder(seriesType, values)
.WithStartIndex(startIndex)
.WithEndIndex(endIndex)
.Build());
return(this);
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
/// <param name="unit">Unit of the serier</param>
/// <param name="color">Color of the series</param>
/// <param name="symbol">Symbol for the marker in a scatter plot series</param>
public Series(string name, SeriesType type, string unit, Color color, ScatterMarkerSymbol symbol = ScatterMarkerSymbol.None)
{
Name = name;
Values = new List <ChartPoint>();
SeriesType = type;
Unit = unit;
Index = 0;
Color = color;
ScatterMarkerSymbol = symbol;
}
public void AddDataSeries(string name, Color color, SeriesType type, int width, bool updateYRange)
{
DataSeries dataSeries = new DataSeries();
dataSeries.color = color;
dataSeries.type = type;
dataSeries.width = width;
dataSeries.updateYRange = updateYRange;
seriesTable.Add(name, dataSeries);
}
protected override void Sample(string chartName,
string seriesName,
int seriesIndex,
SeriesType seriesType,
DateTime time,
decimal value,
string unit = "$")
{
throw new NotImplementedException();
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
/// <param name="unit">Unit of the serier</param>
public Series(string name, SeriesType type = SeriesType.Line, string unit = "$")
{
Name = name;
Values = new List <ChartPoint>();
SeriesType = type;
Unit = unit;
Index = 0;
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.None;
}
public static void DefineChartMeasureType(this Measure m, SeriesType type)
{
var ch2 = m.Grid as OlapChart;
if (ch2 != null)
{
ch2.chartDefinitions.MeasureTypes.Remove(m);
ch2.chartDefinitions.MeasureTypes.Add(m, type);
}
}
public static void DefineChartMeasureType(this Measure m, SeriesType type, bool showPointOnLines)
{
DefineChartMeasureType(m, type);
var ch2 = m.Grid as OlapChart;
if (ch2 != null)
{
ch2.chartDefinitions.ShowPointsOnLines = showPointOnLines;
}
}
public SeriesViewModel(string name, SeriesType type, string argumentName, string valueName, LegendViewModel legend, PaneViewModel pane, YAxisViewModel yAxis)
{
this.Name = name;
this.Type = type;
this.ArgumentName = argumentName;
this.ValueName = valueName;
this.Legend = legend;
this.Pane = pane;
this.YAxis = yAxis;
}
protected virtual void ProcessLiveFeedDataAsync(LiveFeedData liveFeedData)
{
try
{
if (_verbose)
{
StringBuilder sb = new StringBuilder();
sb.Append($"Elapsed:{liveFeedData.Elapsed} ");
sb.Append($"SeriesId:{liveFeedData.SeriesType} ");
sb.Append($"RaceId:{liveFeedData.RaceId} ");
sb.AppendLine($"RunId:{liveFeedData.RunId}");
sb.Append($"LapNumber:{liveFeedData.LapNumber} ");
sb.AppendLine($"FlagState:{liveFeedData.FlagState.ToString()}");
Console.WriteLine("------------------");
Console.WriteLine(sb);
}
if (liveFeedData.RaceId != _lastRaceId ||
liveFeedData.SeriesType != _lastSeriesId ||
liveFeedData.RunId != _lastRunId)
{
if (_verbose)
{
Console.WriteLine("Resetting lap times");
}
ResetLapTimes();
_lapTimes.RaceId = liveFeedData.RaceId;
_lapTimes.SeriesId = (int)liveFeedData.SeriesType;
_lapTimes.RunId = liveFeedData.RunId;
_lapTimes.Elapsed = liveFeedData.Elapsed;
_lapTimes.TrackName = liveFeedData.TrackName;
_lapTimes.RunName = liveFeedData.RunName;
}
_lapTimes = ReadLapTimes(liveFeedData);
if (liveFeedData.Elapsed != _lastElapsed)
{
OnLapTimesUpdated(_lapTimes);
_lastElapsed = liveFeedData.Elapsed;
_lastRaceId = liveFeedData.RaceId;
_lastSeriesId = liveFeedData.SeriesType;
_lastRunId = liveFeedData.RunId;
}
}
catch (Exception ex)
{
ExceptionHandler("Error pumping lap times", ex);
}
}
public ChartPanel(ChartOptions options)
{
this.SeriesType = options.SeriesType;
this.IndicatorType = options.IndicatorType;
this.ChartDrawing = ChartDrawingHelper.GetChartDrawing(SeriesType, IndicatorType);
this.ChartData = options.ChartData;
this.ChartStyle = options.ChartStyle;
if (this.ChartStyle == null)
this.ChartStyle = new DefaultChartStyle();
SizeChanged += ChartPanel_SizeChanged;
}
public override void LoadView ()
{
// Create a chart view that will display the chart.
m_view = new NChartView ();
// Paste your license key here.
m_view.Chart.LicenseKey = "";
// Switch this field to view all types of series.
type = SeriesType.Column2D;
// Switch on antialiasing.
m_view.Chart.ShouldAntialias = true;
if (type >= SeriesType.Column3D) {
// Switch 3D on.
m_view.Chart.DrawIn3D = true;
// Margin to ensure some free space for the iOS status bar and Y-Axis tick titles.
m_view.Chart.CartesianSystem.Margin = new NChartMargin (50.0f, 50.0f, 10.0f, 20.0f);
m_view.Chart.PolarSystem.Margin = new NChartMargin (50.0f, 50.0f, 10.0f, 20.0f);
} else {
// Margin to ensure some free space for the iOS status bar.
m_view.Chart.CartesianSystem.Margin = new NChartMargin (10.0f, 10.0f, 10.0f, 20.0f);
m_view.Chart.PolarSystem.Margin = new NChartMargin (10.0f, 10.0f, 10.0f, 20.0f);
}
// Set data source for the size axis to provide sizes for bubbles.
m_view.Chart.SizeAxis.DataSource = this;
// Create series that will be displayed on the chart.
CreateSeries ();
// Update data in the chart.
m_view.Chart.UpdateData ();
// Set chart view to the controller.
this.View = m_view;
}
public void AddChartPoint( SeriesType Type, double X, double Y )
{
NetworkChart.Series[ (int)Type ].Points.AddXY( X, Y );
}
/// <summary>
/// Add data series to the chart.
/// </summary>
///
/// <param name="name">Data series name.</param>
/// <param name="color">Data series color.</param>
/// <param name="type">Data series type.</param>
/// <param name="width">Width (depends on the data series type, see remarks).</param>
/// <param name="updateYRange">Specifies if <see cref="RangeY"/> should be updated.</param>
///
/// <remarks><para>Adds new empty data series to the collection of data series.</para>
///
/// <para>The <b>updateYRange</b> parameter specifies if the data series may affect displayable
/// Y range. If the value is set to false, then displayable Y range is not updated, but used the
/// range, which was specified by user (see <see cref="RangeY"/> property). In the case if the
/// value is set to true, the displayable Y range is recalculated to fully fit the new data
/// series.</para>
/// </remarks>
///
public void AddDataSeries( string name, Color color, SeriesType type, int width, bool updateYRange )
{
// create new series definition ...
DataSeries series = new DataSeries( );
// ... add fill it
series.color = color;
series.type = type;
series.width = width;
series.updateYRange = updateYRange;
// add to series table
seriesTable.Add( name, series );
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="chartType">Type of chart we should create if it doesn't already exist.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="unit">Unit of the sample</param>
/// <param name="value">Value for the chart sample.</param>
public void Sample(string chartName, ChartType chartType, string seriesName, SeriesType seriesType, DateTime time, decimal value, string unit = "$")
{
lock (_chartLock)
{
//Add a copy locally:
if (!Charts.ContainsKey(chartName))
{
Charts.AddOrUpdate(chartName, new Chart(chartName, chartType));
}
//Add the sample to our chart:
if (!Charts[chartName].Series.ContainsKey(seriesName))
{
Charts[chartName].Series.Add(seriesName, new Series(seriesName, seriesType, unit));
}
//Add our value:
Charts[chartName].Series[seriesName].Values.Add(new ChartPoint(time, value));
}
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="value">Value for the chart sample.</param>
/// <param name="unit">Unit for the sample axis</param>
/// <param name="seriesIndex">Index of the series we're sampling</param>
/// <remarks>Sample can be used to create new charts or sample equity - daily performance.</remarks>
public void Sample(string chartName, string seriesName, int seriesIndex, SeriesType seriesType, DateTime time, decimal value, string unit = "$")
{
var chartFilename = Path.Combine(_chartDirectory, chartName + "-" + seriesName + ".csv");
lock (_chartLock)
{
// Add line to list in dictionary, will be written to file at the end
List<string> rows;
if (!_equityResults.TryGetValue(chartFilename, out rows))
{
rows = new List<string>();
_equityResults[chartFilename] = rows;
}
rows.Add(time + "," + value.ToString("F2", CultureInfo.InvariantCulture));
//Add a copy locally:
if (!Charts.ContainsKey(chartName))
{
Charts.AddOrUpdate(chartName, new Chart(chartName));
}
//Add the sample to our chart:
if (!Charts[chartName].Series.ContainsKey(seriesName))
{
Charts[chartName].Series.Add(seriesName, new Series(seriesName, seriesType, seriesIndex, unit));
}
//Add our value:
Charts[chartName].Series[seriesName].Values.Add(new ChartPoint(time, value));
}
}
/// <summary>
/// Agregado de una serie al grafico
/// </summary>
public void AddDataSeries(string name, Color color, SeriesType type, int width)
{
DataSeries series = new DataSeries();
series.color = color;
series.type = type;
series.width = width;
seriesTable.Add(name, series);
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
/// <param name="index">Index position on the chart of the series</param>
public Series(string name, SeriesType type, int index)
{
Name = name;
SeriesType = type;
Index = index;
Unit = "$";
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.None;
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
/// <param name="index">Index position on the chart of the series</param>
/// <param name="unit">Unit for the series axis</param>
public Series(string name, SeriesType type, int index, string unit)
{
Name = name;
SeriesType = type;
Index = index;
Unit = unit;
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
public Series(string name, SeriesType type = SeriesType.Line)
{
this.Name = name;
this.Values = new List<ChartPoint>();
this.SeriesType = type;
}
/// <summary>
/// Add a sample to the chart specified by the chartName, and seriesName.
/// </summary>
/// <param name="chartName">String chart name to place the sample.</param>
/// <param name="chartType">Type of chart we should create if it doesn't already exist.</param>
/// <param name="seriesName">Series name for the chart.</param>
/// <param name="seriesType">Series type for the chart.</param>
/// <param name="time">Time for the sample</param>
/// <param name="value">Value for the chart sample.</param>
/// <param name="unit">Unit for the chart axis</param>
/// <remarks>Sample can be used to create new charts or sample equity - daily performance.</remarks>
public void Sample(string chartName, string seriesName, int seriesIndex, SeriesType seriesType, DateTime time, decimal value, string unit = "$")
{
Log.Debug("LiveTradingResultHandler.Sample(): Sampling " + chartName + "." + seriesName);
lock (_chartLock)
{
//Add a copy locally:
if (!Charts.ContainsKey(chartName))
{
Charts.AddOrUpdate(chartName, new Chart(chartName));
}
//Add the sample to our chart:
if (!Charts[chartName].Series.ContainsKey(seriesName))
{
Charts[chartName].Series.Add(seriesName, new Series(seriesName, seriesType, seriesIndex, unit));
}
//Add our value:
Charts[chartName].Series[seriesName].Values.Add(new ChartPoint(time, value));
}
Log.Debug("LiveTradingResultHandler.Sample(): Done sampling " + chartName + "." + seriesName);
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
/// <param name="unit">Unit of the serier</param>
public Series(string name, SeriesType type = SeriesType.Line, string unit = "$")
{
Name = name;
Values = new List<ChartPoint>();
SeriesType = type;
Unit = unit;
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
public Series(string name, SeriesType type)
{
Name = name;
SeriesType = type;
Index = 0;
Unit = "$";
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
public Series(string name)
{
Name = name;
SeriesType = SeriesType.Line;
Unit = "$";
Index = 0;
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.Circle;
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
public Series(string name)
{
Name = name;
SeriesType = SeriesType.Line;
Unit = "$";
Index = 0;
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
public Series(string name, SeriesType type)
{
Name = name;
SeriesType = type;
Index = 0;
Unit = "$";
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.Circle;
}
private void SetInnerType(SeriesType ContentField) {
this.ContentField = ((SeriesType)(XTypedServices.GetCloneIfRooted(ContentField)));
XTypedServices.SetName(this, this.ContentField);
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
/// <param name="index">Index position on the chart of the series</param>
/// <param name="unit">Unit for the series axis</param>
public Series(string name, SeriesType type, int index, string unit)
{
Name = name;
SeriesType = type;
Index = index;
Unit = unit;
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.Circle;
}
/// <summary>
/// Add data series to the chart.
/// </summary>
///
/// <param name="name">Data series name.</param>
/// <param name="color">Data series color.</param>
/// <param name="type">Data series type.</param>
/// <param name="width">Width (depends on the data series type, see remarks).</param>
///
/// <remarks><para>Adds new empty data series to the collection of data series. To update this
/// series the <see cref="UpdateDataSeries"/> method should be used.</para>
///
/// <para>The meaning of the width parameter depends on the data series type:
/// <list type="bullet">
/// <item><b>Line</b> - width of the line;</item>
/// <item><b>Dots</b> - size of dots (rectangular dots with specified width and the same height);</item>
/// <item><b>Connected dots</b> - size of dots (dots are connected with one pixel width line).</item>
/// </list>
/// </para>
/// </remarks>
///
public void AddDataSeries( string name, Color color, SeriesType type, int width )
{
AddDataSeries( name, color, type, width, true );
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
/// <param name="unit">Unit of the serier</param>
public Series(string name, SeriesType type = SeriesType.Line, string unit = "$")
{
Name = name;
Values = new List<ChartPoint>();
SeriesType = type;
Unit = unit;
Index = 0;
Color = Color.Empty;
ScatterMarkerSymbol = ScatterMarkerSymbol.Circle;
}
/// <summary>
/// <para>
/// SeriesType acts as a structural base, which is extended through the addition of attributes to reflect the particular needs of a specific key family using the xs:extends element.
/// </para>
/// </summary>
public Series(SeriesType content) {
SetInnerType(content);
}
protected void RegisterChartSeries( SeriesType Type, string FriendlyName, bool bEnabled )
{
NetworkChart.Series.Add( new Series( Type.ToString() ) );
Debug.Assert( NetworkChart.Series[( int )Type].Name == Type.ToString() );
NetworkChart.Series[( int )Type].XValueType = ChartValueType.Int32;
NetworkChart.Series[( int )Type].Font = new System.Drawing.Font( "Tahoma", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ( ( byte )( 0 ) ) );
NetworkChart.Series[( int )Type].Legend = "DefaultLegend";
NetworkChart.Series[( int )Type].ChartArea = "DefaultChartArea";
ChartListBox.Items.Add( FriendlyName );
Debug.Assert( ChartListBox.Items.Count - 1 == ( int )Type );
UpdateChartSeries( Type, SeriesChartType.FastLine, bEnabled );
}
/// <summary>
/// Constructor method for Chart Series
/// </summary>
/// <param name="name">Name of the chart series</param>
/// <param name="type">Type of the chart series</param>
/// <param name="unit">Unit of the serier</param>
/// <param name="color">Color of the series</param>
/// <param name="symbol">Symbol for the marker in a scatter plot series</param>
public Series(string name, SeriesType type, string unit, Color color, ScatterMarkerSymbol symbol = ScatterMarkerSymbol.Circle)
{
Name = name;
Values = new List<ChartPoint>();
SeriesType = type;
Unit = unit;
Index = 0;
Color = color;
ScatterMarkerSymbol = symbol;
}
protected void UpdateChartSeries( SeriesType Type, SeriesChartType ChartType, bool bEnabled )
{
NetworkChart.Series[( int )Type].ChartType = ChartType;
NetworkChart.Series[( int )Type].Enabled = bEnabled;
ChartListBox.SetItemChecked( ( int )Type, bEnabled );
}
/// <summary>
/// Foundational constructor on the series class
/// </summary>
/// <param name="name">Name of the series</param>
/// <param name="type">Type of the series</param>
/// <param name="index">Index position on the chart of the series</param>
public Series(string name, SeriesType type, int index)
{
Name = name;
SeriesType = type;
Index = index;
Unit = "$";
}
private void LoadView ()
{
// Paste your license key here.
mNChartView.Chart.LicenseKey = "";
// Create brushes.
brushes = new NChartBrush[3];
brushes [0] = new NChartSolidColorBrush (Color.Argb (255, (int)(0.38 * 255), (int)(0.8 * 255), (int)(0.91 * 255)));
brushes [1] = new NChartSolidColorBrush (Color.Argb (255, (int)(0.8 * 255), (int)(0.86 * 255), (int)(0.22 * 255)));
brushes [2] = new NChartSolidColorBrush (Color.Argb (255, (int)(0.9 * 255), (int)(0.29 * 255), (int)(0.51 * 255)));
// Switch this field to view all types of series.
type = SeriesType.Column2D;
// Switch on antialiasing.
mNChartView.Chart.ShouldAntialias = true;
if (type >= SeriesType.Column3D) {
// Switch 3D on.
mNChartView.Chart.DrawIn3D = true;
mNChartView.Chart.CartesianSystem.Margin = new NChartTypes.Margin (50.0f, 50.0f, 10.0f, 20.0f);
mNChartView.Chart.PolarSystem.Margin = new NChartTypes.Margin (50.0f, 50.0f, 10.0f, 20.0f);
} else {
mNChartView.Chart.CartesianSystem.Margin = new NChartTypes.Margin (10.0f, 10.0f, 10.0f, 20.0f);
mNChartView.Chart.PolarSystem.Margin = new NChartTypes.Margin (10.0f, 10.0f, 10.0f, 20.0f);
}
// Set data source for the size axis to provide sizes for bubbles.
mNChartView.Chart.SizeAxis.DataSource = this;
// Create series that will be displayed on the chart.
CreateSeries ();
// Update data in the chart.
mNChartView.Chart.UpdateData ();
}
