/// <summary>
/// Example: to get 15 minute bars,
/// interval = ChartInterval.Minute
/// period = 15
/// </summary>
/// <param name="market"></param>
/// <param name="interval"></param>
/// <param name="period"></param>
/// <param name="startDate"></param>
/// <param name="endDate">Leave endDate = null for realtime (endDate = current date)</param>
static public EZChartDataSeries MakeChartData(EZInstrument instrument, ezBarInterval barInterval, DateTime startDate, DateTime?endDate = null)
{
Market market = APIMain.MarketFromInstrument(instrument);
// Load the data for the selected market.
BarInterval interval = new BarInterval(APIConvert.ToChartInterval(barInterval.Interval), barInterval.Period);
ChartDataSeries ctsChartData = new ChartDataSeries(market, interval, SessionTimeRange.Empty);
var session = new ezSessionTimeRange();
EZChartDataSeries chartData = new EZChartDataSeries(market.Description, barInterval, session);
var chartThread = new ChartDataThread(ctsChartData, chartData, startDate, endDate);
var thread = new Thread(new ThreadStart(chartThread.Run));
thread.Name = market.Description + ":" + barInterval;
thread.Start();
return(chartData);
//dataPoints = new List<ezBarDataPoint>();
/*foreach (HistoricalQuote hq in historical)
* {
* ezBarDataPoint dp = new ezBarDataPoint(hq.Open, hq.High, hq.Low, hq.Close, 0, hq.Volume);
* dataPoints.Add(dp);
* }*/
}
void PointStyle_Select(object sender, C1.Win.C1Chart.PointStyleSelectEventArgs e)
{
double val = Convert.ToDouble(c1Chart1.ChartGroups[0].ChartData[e.SeriesIndex].Y[e.PointIndex]);
double maxy = c1Chart1.ChartGroups[0].ChartData.MaxY;
double miny = c1Chart1.ChartGroups[0].ChartData.MinY;
ChartDataSeries ds = c1Chart1.ChartGroups[0].ChartData[e.SeriesIndex];
C1.Win.C1Chart.PointStyle ps = (C1.Win.C1Chart.PointStyle)sender;
if (val > 0)
{
//Color clr = Color.FromArgb( (int)(255 * ( 1 - (maxy -val) / maxy)), Color.Red);
Color clr = Color.FromArgb((int)(255 * (1 - (maxy - val) / maxy)), ds.LineStyle.Color);
ps.LineStyle.Color = clr;
ps.SymbolStyle.Color = clr;
ps.SymbolStyle.OutlineColor = Color.Red;
}
else
{
val = Math.Abs(val);
miny = Math.Abs(miny);
//Color clr = Color.FromArgb( (int)(255 * ( 1 - (miny -val) / miny)), Color.Blue);
Color clr = Color.FromArgb((int)(255 * (1 - (miny - val) / miny)), ds.LineStyle.Color);
ps.LineStyle.Color = clr;
ps.SymbolStyle.Color = clr;
ps.SymbolStyle.OutlineColor = Color.Blue;
}
e.Selected = true;
}
private ChartDataSeries CreateSeries(ChartData cd, double scale, Color clr)
{
int np = 150;
double[] x = new double[np];
double[] y = new double[np];
ChartDataSeries ds = cd.SeriesList.AddNewSeries();
// Create some data
for (int i = 0; i < np; i++)
{
double r = rnd.NextDouble();
x[i] = scale * (1 + r * Math.Sin(0.1 * i) * Math.Sin(0.6 * rnd.NextDouble() * i));
y[i] = i;
}
// Copy data values
ds.X.CopyDataIn(x);
ds.Y.CopyDataIn(y);
// No symbols
ds.SymbolStyle.Shape = SymbolShapeEnum.None;
ds.LineStyle.Color = clr;
return(ds);
}
// Add Chart Labels with beginning and ending dates for each data point
// in the Gantt chart. Labels are placed inside on the western edge.
private void AddGanttTaskLabels(C1Chart chart, ChartDataSeriesCollection cdsc)
{
ChartLabels cl = chart.ChartLabels;
cl.DefaultLabelStyle.BackColor = Color.Transparent;
cl.DefaultLabelStyle.GradientStyle = GradientStyleEnum.None;
cl.DefaultLabelStyle.ForeColor = Color.Azure;
cl.DefaultLabelStyle.HorizontalAlignment = AlignHorzEnum.Far;
C1.Win.C1Chart.LabelsCollection clc = cl.LabelsCollection;
clc.Clear();
int slen = cdsc.Count;
for (int s = 0; s < cdsc.Count; s++)
{
ChartDataSeries cds = cdsc[s];
for (int p = 0; p < cds.Length; p++)
{
C1.Win.C1Chart.Label lab = clc.AddNewLabel();
DateTime start = (DateTime)cds.Y[p];
DateTime end = (DateTime)cds.Y1[p];
lab.Text = start.ToString("ddMMM") + "-" + end.ToString("ddMMM");
lab.AttachMethod = AttachMethodEnum.DataIndex;
lab.AttachMethodData.GroupIndex = 0;
lab.AttachMethodData.SeriesIndex = s;
lab.AttachMethodData.PointIndex = p;
lab.Compass = LabelCompassEnum.West;
lab.Offset = 0;
lab.Visible = true;
}
}
}
private void SetupPrimaryDataSeries()
{
ChartDataSeries mainData = new ChartDataSeries(MainChart, MainChart.YAxis);
// Clear Primary Charts
for (int i = MainChart.DataSeries.Count - 1; i >= 0; i--)
{
ChartDataSeries series = MainChart.DataSeries[i];
if (series.ValueAxis == MainChart.YAxis)
{
MainChart.DataSeries.Remove(series);
}
}
if (Activity != null)
{
// Setup main chart
foreach (ChartDataSeries series in ChartData)
{
MainChart.DataSeries.Add(series);
}
}
ZoomToData();
}
public static void getChartSeries(IDictionary<double, PredictorData> predictorData, PredictionModel model, ChartDataSeries tseries, ChartDataSeries pseries, bool isPace)
{
tseries.Points.Clear();
pseries.Points.Clear();
foreach (PredictorData t in predictorData.Values)
{
if (t.result.ContainsKey(model))
{
TimePredictionResult r = t.result[model];
float x = (float)UnitUtil.Distance.ConvertFrom(t.Distance);
if (!x.Equals(float.NaN))
{
if (tseries.Points.IndexOfKey(x) == -1)
{
tseries.Points.Add(x, new PointF(x, (float)r.PredictedTime));
}
float y = (float)UnitUtil.PaceOrSpeed.ConvertFrom(isPace, t.Distance/r.PredictedTime);
if (pseries.Points.IndexOfKey(x) == -1)
{
pseries.Points.Add(x, new PointF(x, y));
}
}
}
}
}
private void SetupSecondaryDataSeries()
{
// Clear Secondary Charts
for (int i = MainChart.DataSeries.Count - 1; i >= 0; i--)
{
ChartDataSeries series = MainChart.DataSeries[i];
if (series.ValueAxis != MainChart.YAxis)
{
MainChart.DataSeries.Remove(series);
}
}
if (Activity != null)
{
// Setup secondary charts
MainChart.YAxisRight.Clear();
foreach (LineChartTypes chartType in Options.Instance.SelectedExtraCharts)
{
IAxis newAxis = new RightVerticalAxis(MainChart);
ChartDataSeries secondaryData = new ChartDataSeries(MainChart, newAxis);
// Only add if the track if available
if (FillSingleDataSerie(chartType, secondaryData))
{
MainChart.YAxisRight.Add(newAxis);
MainChart.DataSeries.Add(secondaryData);
SetupYAxisFromType(newAxis, chartType);
SetupYAxisAndDataColorFromType(newAxis, secondaryData, chartType);
}
}
}
ZoomToData();
}
private void BsUpDate_Load(object sender, EventArgs e)
{
DataTable dt = S_OperateInfocomend.GetAll_S_OperateInfo();
dataGridView1.DataSource = dt;
dataGridView1.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells;
c1Chart1.BeginInit();
c1Chart1.Reset();
_htLabelX = DBUser.GetAllUserName();
foreach (object var in _htLabelX.Keys)
{
_htLabelY.Add(var, GetOperateCount(var));
}
ChartGroup group = c1Chart1.ChartGroups.Group0;
group.Use3D = true;
c1Chart1.ChartGroups.Group0.ChartType = Chart2DTypeEnum.Bar;
c1Chart1.ChartArea.PlotArea.View3D.Depth = 20;
group.ChartType = Chart2DTypeEnum.Bar;
Axis axis = c1Chart1.ChartArea.AxisX;
axis.AnnoMethod = AnnotationMethodEnum.Values;
//c1Chart1.ChartArea.AxisX.IsLogarithmic = false;
c1Chart1.ChartArea.AxisY.Min = 0;
c1Chart1.ChartArea.AxisX.Rotation = C1.Win.C1Chart.RotationEnum.Rotate0;// 90;
c1Chart1.ChartArea.AxisX.Text = "������Ա";
c1Chart1.ChartArea.AxisY.Text = "��������";
// 3Dͼ�ε����
c1Chart1.ChartArea.PlotArea.View3D.Depth = 20;
// ��y����Ϊ���յ� ��ת�Ƕ�(ֻ��x�ᣬ�������������Ч)
c1Chart1.ChartArea.PlotArea.View3D.Rotation = 40;
// ��x����Ϊ���յ� ��б�Ƕ�
c1Chart1.ChartArea.PlotArea.View3D.Elevation = 40;
// ����3Dͼ�ε���ӰЧ��
c1Chart1.ChartArea.PlotArea.View3D.Shading = ShadingEnum.ColorDark;
Legend legend = c1Chart1.Legend;
legend.Visible = true;
legend.Compass = CompassEnum.North;
ChartData data = group.ChartData;
ChartDataSeries s = null;
PointF[] f = null; //(PointF[])Array.CreateInstance(typeof(PointF), 1);
int i = 0;
foreach (object o in _htLabelX.Keys)
{
f = new PointF[1];
s = new ChartDataSeries();
f[0].X = i;
f[0].Y = S_OperateInfocomend.GetUserCount(o.ToString());
object ooo = _htLabelX[o];
s.Label = ooo.ToString();
s.PointData.CopyDataIn(f);
data.SeriesList.Add(s);
i++;
}
SetChartLabelX("ALL");
c1Chart1.EndInit();
}
public void Refresh()
{
CanvasRoot.Children.Clear();
if (dlx == 0 || dly == 0)
{
return;
}
if (ChartDataSeries.Any())
{
var points = new List <PointF>();
ChartDataSeries.ToList().ForEach(
p =>
{
points.Add(Normalize(p));
}
);
if (points.Count() <= 1)
{
return;
}
WriteableBitmap bitmap = new WriteableBitmap
(
(int)this.RenderSize.Width,
(int)this.RenderSize.Height,
96, 96,
PixelFormats.Bgra32,
null
);
Image figure = new Image {
Source = bitmap
};
bitmap.Lock();
using (System.Drawing.Bitmap buff = new System.Drawing.Bitmap(
(int)bitmap.Width,
(int)bitmap.Height,
bitmap.BackBufferStride,
System.Drawing.Imaging.PixelFormat.Format32bppArgb,
bitmap.BackBuffer))
{
// GDI+ Drawing
using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromImage(buff))
{
Color color = (Foreground as SolidColorBrush).Color;
var brush = System.Drawing.Color.FromArgb(color.A, color.R, color.G, color.B);
var pen = new System.Drawing.Pen(brush, 1); //1 is minimum, bigger thickness could effect performance
graphics.DrawLines(pen, points.ToArray());
graphics.Flush();
}
}
bitmap.AddDirtyRect(new Int32Rect(0, 0, (int)bitmap.Width, (int)bitmap.Height));
bitmap.Unlock();
CanvasRoot.Children.Add(figure);
}
}
/// <summary>
/// Export GearChart data to .csv file.
/// </summary>
/// <remarks>NOTE: This is specific to Gear Chart and may not work properly for other track types.</remarks>
public static void ExportGearTracks(ChartBase chart, string name)
{
ChartDataSeries rawSeries = null, estimateSeries = null;
foreach (ChartDataSeries series in chart.DataSeries)
{
if (series.LineColor == Color.Blue)
{
estimateSeries = series;
}
else if (series.LineColor == Color.Red)
{
rawSeries = series;
}
}
try
{
Cursor.Current = Cursors.WaitCursor;
System.IO.StreamWriter writer = new System.IO.StreamWriter(name);
// Write Header
if (estimateSeries != null && rawSeries != null)
{
writer.WriteLine(chart.XAxis.Label + ", Raw, Estimate");
foreach (PointF item in rawSeries.Points.Values)
{
// Write data
float x = item.X;
writer.WriteLine(item.X + ", " + item.Y + ", " + estimateSeries.GetYValueAtX(ref x));
}
}
else if (rawSeries != null)
{
writer.WriteLine(chart.XAxis.Label + ", Raw");
foreach (PointF item in rawSeries.Points.Values)
{
// Write data
writer.WriteLine(item.X + ", " + item.Y + ", ");
}
}
else
{
writer.WriteLine(chart.XAxis.Label + ", Estimate");
foreach (PointF item in estimateSeries.Points.Values)
{
// Write data
writer.WriteLine(item.X + ", " + item.Y);
}
}
writer.Close();
MessageDialog.Show(CommonResources.Text.MessageExportComplete, Resources.Strings.GearSelection, MessageBoxButtons.OK);
}
catch { }
finally
{
Cursor.Current = Cursors.Default;
}
}
public void LoadHistoricalChartData(object chartIdentifier, DateTime startDate, DateTime endDate)
{
ChartIdentifier = chartIdentifier;
StartDate = startDate;
EndDate = endDate;
Market market = chartIdentifier as Market;
ezDateRange dateRangeRequested = new ezDateRange();
ezDateRange dateRangeProcessed = new ezDateRange();
// Start with an empty set of TradeBars.
chartData.TradeBars.Clear();
// Load the data for the selected market.
BarInterval interval = new BarInterval(APIConvert.ToChartInterval(BarInterval.Interval), BarInterval.Period);
ChartDataSeries ctsChartData = new ChartDataSeries(market, interval, SessionTimeRange.Empty);
var session = new ezSessionTimeRange();
/*EZChartDataSeries myChartData = new EZChartDataSeries(market.Description, BarInterval, session);
* myChartData.DataLoadComplete += myChartData_DataLoadComplete;
* myChartData.DataSeriesUpdated += myChartData_DataSeriesUpdated;*/
var chartThread = new ChartDataThread(ctsChartData, chartData, startDate, endDate);
var thread = new Thread(new ThreadStart(chartThread.Run));
thread.Name = market.Description + ":" + BarInterval;
thread.Start();
//if (DataLoadComplete != null) DataLoadComplete(this, new ezDataLoadCompleteEventArgs(zDataLoadStatus.Success, dateRangeRequested, dateRangeProcessed));
}
void AddLengenEntry(StackPanel legend, ChartDataSeries s, Path shape)
{
StackPanel legendEntry = new StackPanel();
legendEntry.Margin = new Thickness(2);
legendEntry.Orientation = Orientation.Horizontal;
legendEntry.Background = Brushes.Transparent;
legendEntry.Tag = s;
legendEntry.PreviewMouseDown += OnSelectLegendEntry;
legendEntry.IsHitTestVisible = true;
legendEntry.MouseEnter += OnLegendEntryMouseEnter;
legendEntry.MouseLeave += OnLegendEntryMouseLeave;
legend.Children.Add(legendEntry);
s.UserData = shape;
Rectangle swatch = new Rectangle();
swatch.Margin = new Thickness(4, 1, 2, 1);
swatch.Width = 12;
swatch.Height = 12;
swatch.Stroke = shape.Stroke;
swatch.StrokeThickness = 1;
swatch.Fill = shape.Fill;
legendEntry.Children.Add(swatch);
TextBlock label = new TextBlock();
label.Text = s.Category.Name;
label.Margin = new Thickness(2, 1, 4, 1);
legendEntry.Children.Add(label);
}
public ChartData(ChartControl chart, History history, IReadOnlyList <Consumer> consumers)
{
Chart = chart;
History = history;
// Create the solar output chart data
Solar = new ChartDataSeries("Solar Output", ChartDataSeries.EFormat.XRealYReal, new ChartDataSeries.OptionsData
{
PlotType = ChartDataSeries.EPlotType.Line,
Colour = Colour32.DarkGreen,
LineWidth = 3.0,
PointsOnLinePlot = false,
})
{
Chart = chart
};
// Create the combined consumption chart data
Consumption = new ChartDataSeries("Combined", ChartDataSeries.EFormat.XRealYReal, new ChartDataSeries.OptionsData
{
PlotType = ChartDataSeries.EPlotType.StepLine,
Colour = Colour32.DarkRed,
LineWidth = 3.0,
PointsOnLinePlot = false,
})
{
Chart = chart
};
// Create chart data for each existing consumer
Consumers = consumers.Select(x => CreateSeriesForConsumer(x)).ToList();
}
private void SetHistogramData()
{
Area carea = c1Chart1.ChartArea;
if (carea.AxisX.ValueLabels[0] != null)
{
// get the Target Coordinates
DateTime xtarget = carea.AxisX.ValueLabels[0].DateTimeValue;
DateTime xtime = new DateTime(xtarget.Year, xtarget.Month, xtarget.Day);
DateTime mintime = new DateTime(sjBegin.Value.Year, sjBegin.Value.Month, sjBegin.Value.Day);
for (int m = 0; m < c1Chart1.ChartGroups[0].ChartData.SeriesList.Count; m++)
{
//// get the data point coordinates from the chart.
ChartDataSeries cds = c1Chart1.ChartGroups[0].ChartData.SeriesList[m];
PointF[] cdata = (PointF[])cds.PointData.CopyDataOut();
double dy = 0;
//// find the distance from each scatter point to the target point.
int n = cdata.Length;
for (int i = 0; i < n; i++)
{
double dx = cdata[i].X;
if (dx == xtime.ToOADate())
{
dy = cdata[i].Y;
}
}
c1Chart1.ChartGroups[0].ChartData.SeriesList[m].Label = xtime.GetDateTimeFormats('M')[0].ToString() + ylmcysj[m].ToString() + ":" + dy.ToString("0.00");
}
}
}
public ChartDataThread(ChartDataSeries ctsChartData, EZChartDataSeries chartData, DateTime startDate, DateTime endDate)
{
this.ctsChartData = ctsChartData;
this.chartData = chartData;
this.startDate = startDate;
this.endDate = endDate;
}
public ChartUI()
{
InitializeComponent();
m_chart.Options.Orthographic = true;
m_chart.Options.SceneBorderThickness = 1;
m_chart.Options.SceneBorderColour = Colour32.Black;
m_chart.Scene.ContextMenu.DataContext = this;
m_obj0 = new View3d.Object(
"test_object", 0xFFFFFFFF, 5, 18, 1,
new View3d.Vertex[]
{
new View3d.Vertex(new v4(+0, +1, +0, 1), new v4(+0.00f, +1.00f, +0.00f, 0), 0xffff0000, new v2(0.50f, 1)),
new View3d.Vertex(new v4(-1, -1, -1, 1), new v4(-0.57f, -0.57f, -0.57f, 0), 0xff00ff00, new v2(0.00f, 0)),
new View3d.Vertex(new v4(-1, -1, +1, 1), new v4(-0.57f, -0.57f, +0.57f, 0), 0xff0000ff, new v2(0.25f, 0)),
new View3d.Vertex(new v4(+1, -1, +1, 1), new v4(+0.57f, -0.57f, +0.57f, 0), 0xffff00ff, new v2(0.50f, 0)),
new View3d.Vertex(new v4(+1, -1, -1, 1), new v4(+0.57f, -0.57f, -0.57f, 0), 0xff00ffff, new v2(0.75f, 0)),
},
new ushort[]
{
0, 1, 2,
0, 2, 3,
0, 3, 4,
0, 4, 1,
4, 3, 2,
2, 1, 4,
},
new View3d.Nugget[]
{
new View3d.Nugget(View3d.ETopo.TriList, View3d.EGeom.Vert | View3d.EGeom.Norm | View3d.EGeom.Colr),
},
null);
m_chart.BuildScene += (s, a) =>
{
m_chart.Scene.Window.AddObject(m_obj0);
};
m_series = new ChartDataSeries("waves", ChartDataSeries.EFormat.XRealYReal);
m_series.Options.Colour = Colour32.Blue;
m_series.Options.PlotType = ChartDataSeries.EPlotType.Bar;
m_series.Options.PointStyle = EPointStyle.Triangle;
m_series.Options.PointSize = 50f;
m_series.Options.LineWidth = 3f;
m_series.Chart = m_chart;
{
using var lk = m_series.Lock();
for (int i = 0; i != 100000; ++i)
{
lk.Add(new ChartDataSeries.Pt(0.01 * i, Math.Sin(0.01 * i * Math_.Tau)));
}
}
m_legend = new ChartDataLegend();
m_chart.Elements.Add(m_legend);
MyLegendItems = new ListCollectionView(new[] { m_series });
ShowBoobs = Command.Create(this, ShowBoobsInternal);
DataContext = this;
}
void chart_ShowTooltip(object sender, ShowTooltipEventArgs e)
{
if (sender is ChartDataSeries)
{
ChartDataSeries cds = (ChartDataSeries)sender;
e.TooltipText = (cds.Tag as List <string>)[e.PointIndex] + "\r\nRTU数量:" + cds.Y[e.PointIndex];
}
}
void OnSelectLegendEntry(object sender, MouseButtonEventArgs e)
{
// bring this legend entry to the front so user can see item values.
StackPanel legendEntry = (StackPanel)sender;
ChartDataSeries series = (ChartDataSeries)legendEntry.Tag;
this.SelectedSeries = series;
}
private void RefreshChartRunning()
{
// Initialize the charts, dataseries, and variables
IAxis axis = scoreChart.YAxis;
ChartDataSeries dsFactor = new ChartDataSeries(scoreChart, axis);
ChartDataSeries dsFactorLine = new ChartDataSeries(scoreChart, axis);
PointF point = new PointF();
// Prep the variables for the running equation
double grade = 0;
double g = 0;
double g0 = .184f;
double a0 = 1.68f;
double a1 = 54.9f;
double a2 = -102f;
double a3 = 200f;
double de = 0;
double pos15 = 0;
// Running scores from -100% to 100%, do the math
for (float i = -100; i <= 100; i++)
{
grade = i / 100f;
g = grade / Math.Sqrt(1 + grade * grade);
de = a0 + a1 * Math.Pow(g + g0, 2) + a2 * Math.Pow(g + g0, 4) + a3 * Math.Pow(g + g0, 6);
de = de - 1.5f;
point.X = i;
point.Y = (float)de;
dsFactor.Points.Add(i, point);
// Find the value at grade = 15 for our autozoom
if (i == 15)
{
pos15 = de;
}
}
// Set up the axis and the chart
axis.Label = Resources.Strings.Label_Score + "/km";
scoreChart.XAxis.Label = CommonResources.Text.LabelGrade;
scoreChart.DataSeries.Clear();
dsFactor.ChartType = ChartDataSeries.Type.Line;
dsFactor.LineColor = Color.Blue;
dsFactor.ValueAxis = axis;
// Add the dataseries to the chart
scoreChart.DataSeries.Add(dsFactor);
// Autozoom from -15 to 15
scoreChart.AutozoomToData(true);
double ratio = (scoreChart.XAxis.MaxOriginFarValue - scoreChart.XAxis.OriginValue) / 30;
scoreChart.XAxis.PixelsPerValue = scoreChart.XAxis.PixelsPerValue * ratio;
scoreChart.XAxis.OriginValue = -15;
ratio = (de - scoreChart.YAxis.OriginValue) / pos15;
scoreChart.YAxis.PixelsPerValue = scoreChart.YAxis.PixelsPerValue * ratio;
}
void CreateLineChart(int npoints)
{
ChartData cd = c1Chart1.ChartGroups[0].ChartData;
cd.SeriesList.Clear();
ChartLabels lbls = c1Chart1.ChartLabels;
lbls.LabelsCollection.Clear();
int[] x = new int[npoints];
int[] y = new int[npoints];
ChartDataSeries ds = cd.SeriesList.AddNewSeries();
ds.SymbolStyle.Shape = SymbolShapeEnum.None;
ds.LineStyle.Color = Color.Blue;
for (int i = 0; i < npoints; i++)
{
x[i] = i;
if (i == 0)
{
y[i] = _rnd.Next(1000);
}
else
{
y[i] = y[i - 1] + (_rnd.Next(1000) - 500) / 3;
}
if (i % 5 == 0)
{
C1.Win.C1Chart.Label lbl = lbls.LabelsCollection.AddNewLabel();
lbl.Text = y[i].ToString();
lbl.AttachMethod = AttachMethodEnum.DataIndex;
lbl.AttachMethodData.GroupIndex = 0;
lbl.AttachMethodData.SeriesIndex = 0;
lbl.AttachMethodData.PointIndex = i;
lbl.Offset = 1;
lbl.Connected = true;
lbl.Style.ForeColor = Color.Red;
lbl.Style.BackColor = Color.White;
lbl.Style.Border.BorderStyle = BorderStyleEnum.Solid;
lbl.Visible = true;
}
}
ds.X.CopyDataIn(x);
ds.Y.CopyDataIn(y);
c1Chart1.ChartArea.AxisX.ScrollBar.Min = 0;
c1Chart1.ChartArea.AxisX.ScrollBar.Max = 499;
c1Chart1.ChartArea.AxisX.ScrollBar.Visible = true;
btnArrangeLine.Enabled = true;
}
// Adds a new series to the Gantt chart accepting a task name,
// an array of starting times and an array of ending times.
private void AddGanttSeriesData(ChartDataSeriesCollection cdsc,
string taskName, DateTime[] startTimes, DateTime[] endTimes)
{
ChartDataSeries cds = cdsc.AddNewSeries();
cds.Label = taskName;
cds.Y.CopyDataIn(startTimes);
cds.Y1.CopyDataIn(endTimes);
}
public void GetStuff(ChartDataSeries ser)
{
if (wasSet)
{
ser.LineStyle.Color = lineColor;
ser.SymbolStyle.Color = symbolColor;
ser.SymbolStyle.Shape = symbolShape;
}
}
private void ZoomDataSeries(ZoomBoundsInfo infos, ChartDataSeries dataSeries)
{
if (dataSeries == null)
{
return;
}
ZoomSymbolStyle(infos, dataSeries.SymbolStyle);
ZoomLineStyle(infos, dataSeries.LineStyle);
}
void chart_ShowTooltip(object sender, ShowTooltipEventArgs e)
{
if (sender is ChartDataSeries)
{
ChartDataSeries ds = (ChartDataSeries)sender;
object obj = ds.Tag;
e.TooltipText += "\r\n" + (obj as string[])[e.PointIndex];
}
}
private void ValueLabelChangedHandler(object sender, EventArgs e)
{
ValueLabelsCollection vls = c1Chart1.ChartArea.AxisX.ValueLabels;
string minMarker = "M1", maxMarker = "M2";
if (vls["M1"].NumericValue > vls["M2"].NumericValue)
{
minMarker = "M2"; maxMarker = "M1";
}
float minValue = (float)vls[minMarker].NumericValue;
float maxValue = (float)vls[maxMarker].NumericValue;
string name = (string)zoneSelect.Items[3];
AlarmZone az = c1Chart1.ChartArea.PlotArea.AlarmZones[name];
int gi = az.GroupIndex;
int si = az.PolygonData.SeriesIndex;
ChartGroup cg = c1Chart1.ChartGroups[gi];
ChartDataSeries cds = cg.ChartData.SeriesList[si];
PointF[] pfs = (PointF[])cds.PointData.CopyDataOut();
int pmin = -1, pmax = -1;
float minY = float.MaxValue, maxY = float.MinValue;
for (int p = 0; p < pfs.Length; p++)
{
if (pmin < 0 && pfs[p].X >= minValue)
{
pmin = p;
}
if (pmax < 0 && pfs[p].X >= maxValue)
{
pmax = (pfs[p].X == maxValue) ? p : p - 1;
break;
}
if (pmin >= 0)
{
if (pfs[p].Y < minY)
{
minY = pfs[p].Y;
}
if (pfs[p].Y > maxY)
{
maxY = pfs[p].Y;
}
}
}
az.NearExtent = pfs[pmin].X;
az.FarExtent = pfs[pmax].X;
az.UpperExtent = maxY;
az.LowerExtent = minY;
}
public ChartUI()
{
InitializeComponent();
m_chart = Controls.Add2(new ChartControl {
Dock = DockStyle.Fill, Title = "My Chart"
});
m_chart.Options.Orthographic = true;
m_chart.XAxis.Label = "X Axis";
m_chart.YAxis.Label = "Y Axis";
m_obj0 = new View3d.Object(
"test_object", 0xFFFFFFFF, 5, 18, 1,
new View3d.Vertex[]
{
new View3d.Vertex(new v4(+0, +1, +0, 1), new v4(+0.00f, +1.00f, +0.00f, 0), 0xffff0000, new v2(0.50f, 1)),
new View3d.Vertex(new v4(-1, -1, -1, 1), new v4(-0.57f, -0.57f, -0.57f, 0), 0xff00ff00, new v2(0.00f, 0)),
new View3d.Vertex(new v4(+1, -1, -1, 1), new v4(+0.57f, -0.57f, -0.57f, 0), 0xff0000ff, new v2(0.25f, 0)),
new View3d.Vertex(new v4(+1, -1, +1, 1), new v4(+0.57f, -0.57f, +0.57f, 0), 0xffff00ff, new v2(0.50f, 0)),
new View3d.Vertex(new v4(-1, -1, +1, 1), new v4(-0.57f, -0.57f, +0.57f, 0), 0xff00ffff, new v2(0.75f, 0)),
},
new ushort[]
{
0, 1, 2,
0, 2, 3,
0, 3, 4,
0, 4, 1,
4, 3, 2,
2, 1, 4,
},
new View3d.Nugget[]
{
new View3d.Nugget(View3d.ETopo.TriList, View3d.EGeom.Vert | View3d.EGeom.Norm | View3d.EGeom.Colr),
}, null);
m_chart.ChartRendering += (s, a) =>
{
a.AddToScene(m_obj0);
};
m_series = new ChartDataSeries("waves", ChartDataSeries.EFormat.XRealYReal);
using (var lk = m_series.Lock())
{
for (int i = 0; i != 100000; ++i)
{
lk.Add(new ChartDataSeries.Pt(0.01 * i, Math.Sin(0.01 * i * Math_.Tau)));
}
}
m_series.Options.Colour = Colour32.Blue;
m_series.Options.PlotType = ChartDataSeries.EPlotType.Bar;
m_series.Options.PointStyle = ChartDataSeries.EPointStyle.Triangle;
m_series.Options.PointSize = 50f;
m_series.Options.LineWidth = 3f;
m_series.Chart = m_chart;
m_legend = new ChartDataLegend();
m_chart.Elements.Add(m_legend);
}
public void SetStuff(ChartDataSeries ser)
{
if (!wasSet)
{
lineColor = ser.LineStyle.Color;
symbolColor = ser.SymbolStyle.Color;
symbolShape = ser.SymbolStyle.Shape;
wasSet = true;
}
}
// Adds a new series to the Gantt chart accepting a task name,
// an array of starting times and an array of ending times.
private void AddGanttSeriesData(ChartDataSeriesCollection cdsc, string ServerName, string IP, string[] runtimelist, DateTime[] startTimes, DateTime[] endTimes)
{
ChartDataSeries cds = cdsc.AddNewSeries();
cds.Label = ServerName;
cds.Y.CopyDataIn(startTimes);
cds.Y1.CopyDataIn(endTimes);
cds.Tag = runtimelist;
cds.TooltipText = ServerName + "\r\n" + IP;
}
private void c1Chart1_DrawLegendEntry(object sender, C1.Win.C1Chart.DrawLegendEntryEventArgs e)
{
ChartDataSeries ds = (ChartDataSeries)e.Entry;
// Draw legend text using selection color
if (ds != null && ds.Group.ChartData.SeriesList.IndexOf(ds) == selectedIndex)
{
e.TextColor = selectionColor;
}
}
private void ResetSeries(int s)
{
if (initialSeriesStuff == null)
{
return;
}
ChartDataSeries ser = c1Chart1.ChartGroups[0].ChartData[s];
initialSeriesStuff[s].GetStuff(ser);
}
private void ZoomDataSeries(ZoomFontInfo infos, ChartDataSeries dataSeries)
{
if (dataSeries == null)
{
return;
}
if (dataSeries.DataLabel != null)
{
ZoomStyle(infos, dataSeries.DataLabel.Style);
}
}
private static IChartDataSeries <DateTime> GetPortfolioValuation(PortfolioValuationSummaryDataModel portfolioValuationSummaryDataModel)
{
IEnumerable <ChartDataPoint <DateTime> > portfolioDataPoints = portfolioValuationSummaryDataModel.PortfolioValuationData.Select(x =>
{
return(new ChartDataPoint <DateTime>(x.ValuationDate, x.PortfolioValuation));
});
var portfolioValuationSeries = new ChartDataSeries <DateTime>("Portfolio Valuation", portfolioDataPoints, 3);
return(portfolioValuationSeries);
}
public void setData()
{
bool showPage = m_showPage;
m_showPage = false;
//Get the (cached?) list/chart
makeData();
summaryList.Visible = !Settings.ShowChart;
chart.Visible = Settings.ShowChart;
if (!Settings.ShowChart)
{
summaryList.Visible = true;
RefreshColumns(!m_ppcontrol.IsOverridden && (m_ppcontrol.ChkHighScore || m_ppcontrol.Activities.Count > 1));
summaryList.RowData = m_predictorData.Values;
}
else
{
chart.YAxis.Formatter = new Formatter.SecondsToTime();
chart.XAxis.Formatter = new Formatter.General(UnitUtil.Distance.DefaultDecimalPrecision);
chart.XAxis.Label = UnitUtil.Distance.LabelAxis;
chart.YAxis.Label = UnitUtil.Time.LabelAxis;
chart.YAxisRight[0].Label = UnitUtil.PaceOrSpeed.LabelAxis(Settings.ShowPace);
if (Settings.ShowPace)
{
chart.YAxisRight[0].Formatter = new Formatter.SecondsToTime();
}
else
{
chart.YAxisRight[0].Formatter = new Formatter.General(UnitUtil.Speed.DefaultDecimalPrecision);
}
chart.DataSeries.Clear();
foreach (PredictionModel t in PredictionModelUtil.List)
{
PredictionModelUtil.ChartColors c;
if (t == Settings.Model)
{
c = new PredictionModelUtil.ChartColors(Color.Black);
}
else
{
c = PredictionModelUtil.Colors(t);
}
ChartDataSeries tseries = new ChartDataSeries(chart, chart.YAxis);
tseries.LineColor = c.LineNormal;
tseries.FillColor = c.FillNormal;
tseries.SelectedColor = c.FillSelected;
ChartDataSeries pseries = new ChartDataSeries(chart, chart.YAxisRight[0]);
pseries.LineColor = c.LineNormal;
pseries.FillColor = c.FillNormal;
pseries.SelectedColor = c.FillSelected;
PredictorData.getChartSeries(m_predictorData, t, tseries, pseries, Settings.ShowPace);
chart.DataSeries.Add(tseries);
chart.DataSeries.Add(pseries);
}
chart.AutozoomToData(true);
}
m_showPage = showPage;
}
private void showGraph()
{
IList<Result> results = cachedResults[Settings.Domain][Settings.Image][Settings.UpperBound];
if (!Goal.IsZoneGoal(Settings.Image))
{
// Graph can only be calculated for some X-axis
chart.DataSeries.Clear();
chart.XAxis.Label = Goal.getGoalParameterLabel(Settings.Image, speedUnit);
chart.YAxis.Label = Goal.getGoalParameterLabel(Settings.Domain, speedUnit);
if (results == null)
{
IList<Goal> goals = Goal.generateSettingsGoals();
results = HighScore.calculateActivities(m_activities, m_pauses, goals, progressBar);
cachedResults[Settings.Domain][Settings.Image][Settings.UpperBound] = results;
}
}
else
{
//No graph for zones
results = null;
}
if (results == null || results.Count == 0)
{
Remarks.Text = Resources.NoResultsForSettings;
Remarks.Visible = true;
}
else
{
ChartDataSeries series = new ChartDataSeries(chart, chart.YAxis);
Goal.setAxisType(chart.XAxis, Settings.Image);
Goal.setAxisType(chart.YAxis, Settings.Domain);
foreach (Result result in results)
{
float x = (float)result.getValue(Settings.Image, speedUnit);
float y = (float)result.getValue(Settings.Domain, speedUnit);
if (!x.Equals(float.NaN) && !float.IsInfinity(y) &&
series.Points.IndexOfKey(x) == -1)
{
series.Points.Add(x, new PointF(x, y));
}
}
chart.DataSeries.Add(series);
chart.AutozoomToData(true);
chart.Visible = true;
}
}
