public StackedAreaSeries SetProperties(StackedAreaSeries NewSeries, DataPt Pt)
{
NewSeries.PointForeground = Pt.Marker.Graphics.GetBackgroundBrush();
NewSeries.PointGeometrySize = Pt.Marker.Radius;
return(NewSeries);
}
/// <summary>
/// Gets a new stacked area series for a given point size, color and title.
/// </summary>
/// <param name="title">The line series title.</param>
/// <param name="color">The color for the series.</param>
/// <param name="pointSize">The size of the points in pixels.</param>
/// <returns>The newly created line series.</returns>
private StackedAreaSeries GetBasicStackedAreaSeries(string title, Color color, double pointSize)
{
// Set up the gradient brush.
LinearGradientBrush gradientBrush = new LinearGradientBrush
{
StartPoint = new System.Windows.Point(0, 0),
EndPoint = new System.Windows.Point(0, 1)
};
gradientBrush.GradientStops.Add(pointSize > 0.1 ? new GradientStop(color, 0) : new GradientStop(Colors.Transparent, 1));
gradientBrush.GradientStops.Add(new GradientStop(Colors.Transparent, 1));
StackedAreaSeries lineSeries = new StackedAreaSeries
{
Title = title,
DataLabels = false,
LabelPoint = PointLabel,
LineSmoothness = 0.2,
PointGeometrySize = pointSize,
Foreground = new SolidColorBrush(color),
PointForeground = new SolidColorBrush(color),
Stroke = new SolidColorBrush(color),
Fill = gradientBrush
};
return(lineSeries);
}
/// <summary>
/// Create chart series for each coin
/// </summary>
private void PlotPaymentChart()
{
try
{
// Exit if no fiat currency is selected
if (Application.Current.Properties["Currency"] == null)
{
return;
}
// New list of strings used for labels when plotting the chart
List <string> labels = new List <string>();
// New collection of series
seriesCollection = new SeriesCollection();
foreach (MinerPaymentSummary MinerPaymentSummary in MinerPaymentsData.MinerPaymentSummaryList)
{
StackedAreaSeries stackedColumnSeries = new StackedAreaSeries();
ChartValues <DateTimePoint> chartValues = new ChartValues <DateTimePoint>();
// Format series fill, stroke, etc
FormatChartSeries(MinerPaymentSummary, stackedColumnSeries);
// Iterate through each day and add a chart point
foreach (MinerPaymentsGroupedByDay minerPaymentsGroupedByDay in MinerPaymentSummary.MinerPaymentsGroupedByDayList.Where(x => x.PaymentDate >= DateTime.Now.AddDays(-30)).OrderByDescending(y => y.PaymentDate))
{
DateTimePoint dateTimePoint = CreateChartDataPoint(minerPaymentsGroupedByDay);
chartValues.Add(dateTimePoint);
}
// Add coin symbol to labels to show up in the UI
labels.Add(MinerPaymentSummary.CoinType.ToString());
// Add 0 values for any dates with no payments in order to render the chart properly
PaymentChartDataBackFill paymentChartDataBackFill = new PaymentChartDataBackFill();
stackedColumnSeries.Values = paymentChartDataBackFill.BackFillList(chartValues);
seriesCollection.Add(stackedColumnSeries);
}
// Add a line series for the Total Line
seriesCollection.Add(this.AddTotalLineSeries());
// Axis label formats
XFormatter = val => new DateTime((long)val).ToShortDateString();
YFormatter = val => String.Format("{0} {1}", Math.Round(val, 4).ToString(), Application.Current.Properties["Currency"].ToString());
// Rebind UI
OnPropertyChanged("SeriesCollection");
OnPropertyChanged("XFormatter");
OnPropertyChanged("YFormatter");
}
catch (Exception e)
{
ShowError(String.Format("{0} {1}", "Error plotting payment chart", e.Message));
}
}
public SeriesCollection ToStackedAreaSeriesCollection()
{
SeriesCollection seriesCollection = new SeriesCollection();
for (int r = 0; r < SeriesD.Count; r++)
{
StackedAreaSeries series = new StackedAreaSeries();
ConfigureSeries(series, r);
seriesCollection.Add(series);
}
return(seriesCollection);
}
private void createStackedAreaChart()
{
AreaCollection = new SeriesCollection();
using (var db = new LiteDatabase(@"AdatBazis.db"))
{
var col = db.GetCollection <CustomPropAggregator>("customList");
var results = col.Find(Query.All("TimeStamp"));
results = results.OrderBy(x => x.TimeStamp).ToList();
var titles = new List <string>();
foreach (var result in results)
{
titles.Add(result.Title);
}
titles.Sort();
foreach (var title in titles.Distinct())
{
var cv = new ChartValues <DateTimePoint>();
foreach (var result in results)
{
if (result.Title == title)
{
cv.Add(new DateTimePoint(new DateTime(result.TimeStamp.Year, result.TimeStamp.Month, 1), (double)result.Spending));
}
}
var sas = new StackedAreaSeries
{
Title = title,
Values = cv,
LineSmoothness = 0.2
};
AreaCollection.Add(sas);
System.Windows.Controls.Panel.SetZIndex(sas, 0);
}
};
if (!yearlyMode)
{
XFormatter = val => new DateTime((long)val).ToString("MMMM");
}
else
{
XFormatter = val => new DateTime((long)val).ToString("YYYY");
}
DataContext = this;
}
private void StatsOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs)
{
this.Dispatcher.Invoke(() =>
{
if (propertyChangedEventArgs.PropertyName == nameof(this._stats.ConnectionStats))
{
this._ticks++;
foreach (var connection in this._stats.ConnectionStats.Connections)
{
if (!this._guidToSeries.ContainsKey(connection.AdapterId))
{
var newAdapter = this._stats.Adapters.FirstOrDefault(a => a.AdapterId == connection.AdapterId);
//If we don't yet have any information on the new adapter, we just skip the value.
if (newAdapter == null)
{
continue;
}
var serie = new StackedAreaSeries()
{
Title = newAdapter.Name,
Values = new ChartValues <MeasureModel>(),
//LineSmoothness = 0
};
this.SeriesCollection.Add(serie);
this._guidToSeries.Add(newAdapter.AdapterId, serie);
}
var chartValues = this._guidToSeries[connection.AdapterId].Values;
chartValues.Add(new MeasureModel(this._ticks, connection.TotalBps));
if (chartValues.Count > 50)
{
chartValues.RemoveAt(0);
}
}
this.SetAxisLimit(this._ticks);
}
});
}
/// <summary>
/// Creates a new stacked area series point with a given name and value.
/// </summary>
/// <param name="title">The line series title.</param>
/// <param name="xValues">The x date values for the series.</param>
/// <param name="yValues">The y values for the series.</param>
/// <param name="color">The color for the series.</param>
/// <param name="pointSize">The size of the points in pixels.</param>
/// <returns>The newly created line series.</returns>
public StackedAreaSeries CreateStackedAreaSeries(string title, List <DateTime> xValues, List <double> yValues, Color color, double pointSize = 15d)
{
// Update the maxima and minima.
UpdateMaxMinValues(xValues, yValues);
// Get the date time point values.
ChartValues <DateTimePoint> values = new ChartValues <DateTimePoint>();
for (int i = 0; i < xValues.Count && i < yValues.Count; i++)
{
values.Add(new DateTimePoint(xValues[i], yValues[i]));
}
// Finally create the line series and set the values.
StackedAreaSeries lineSeries = GetBasicStackedAreaSeries(title, color, pointSize);
lineSeries.Values = values;
return(lineSeries);
}
void Loadchart()
{
SeriesCollectionline = new SeriesCollection();
SeriesCollectionpie = new SeriesCollection();
casenum = new int[4] {
0, 0, 0, 0
};
for (int i = 1; i < 5; i++)
{
StackedAreaSeries stackedareaSeries = new StackedAreaSeries
{
Title = "第" + i + "类",
LineSmoothness = i
};
var Values = new ChartValues <DateTimePoint>();
var days = (EndDateTime - StartDateTime).Days;
DateTime queryDate = StartDateTime.AddDays(-1);
for (int j = 0; j < days; j++)
{
queryDate = queryDate.AddDays(1);
int num = GetCaseCount(queryDate.Date, queryDate.Date, i);
casenum[i - 1] += num;
Values.Add(new DateTimePoint(queryDate.Date, Convert.ToDouble(num)));
}
stackedareaSeries.Values = Values;
SeriesCollectionline.Add(stackedareaSeries);
PieSeries ps = new PieSeries();
ps.Title = "第" + i + "类";
ps.Values = new ChartValues <int>(new int[1] {
casenum[i - 1]
});
ps.DataLabels = true;
ps.LabelPoint = PointLabel;
SeriesCollectionpie.Add(ps);
}
linechart.Series = SeriesCollectionline;
piechart.Series = SeriesCollectionpie;
}
protected override ISeries ConvertInternal(IDataObject data, ResourceDictionary availableResources,
Color resolvedColor, ObservableCollection <IDataObject> seriesCollection, Control tooltip)
{
// Chart control uses SeriesDataConstants.Visibility property from Tag
var series = new StackedAreaSeries {
Tag = data
};
var orderedSeriescollection = seriesCollection.OrderBy(s => s[ChartingConstants.SeriesOrderPropertyName] ?? 0);
foreach (var stackableSeries in orderedSeriescollection)
{
var idoCollection = stackableSeries[SeriesDataConstants.Data] as ICollection <IDataObject>;
var dataPoints = new IDataObject[idoCollection.Count];
idoCollection.CopyTo(dataPoints, 0);
var observableDataPoints = new BatchObservableCollection <IDataObject>(dataPoints);
SeriesDefinitionConverter.Convert(stackableSeries, observableDataPoints, availableResources,
(s) => { series.SeriesDefinitions.Add((SeriesDefinition)s); });
}
return(series);
}
public static Tuple <Axis, Axis, List <Series> > ConfigureChartByChartType(
string SeriesChartType,
List <string> lstBoxSelectedStringValues)
{
DefaultTooltip defaultTooltip = new DefaultTooltip();
defaultTooltip.SelectionMode = TooltipSelectionMode.OnlySender;
Axis AbscissaAxis = new Axis()
{
Separator = new Separator()
{
Step = 1, IsEnabled = false
},
Title = "Date",
Labels = lstBoxSelectedStringValues,
LabelsRotation = 20,
FontSize = 16
};
Axis OrdinateAxis = new Axis()
{
Title = "Time Duration (hrs)",
FontSize = 16,
LabelFormatter = v => v.ToString("N0")
};
switch (SeriesChartType)
{
case "Column":
ColumnSeries columnSeries = new ColumnSeries()
{
Title = "GeneratorOn (hrs)",
DataLabels = true,
Values = new ChartValues <double>()
};
List <Series> columnSeriesList = new List <Series>();
columnSeriesList.Add(columnSeries);
return(new Tuple <Axis, Axis, List <Series> >(
OrdinateAxis,
AbscissaAxis,
columnSeriesList));
case "Stacked Column":
StackedColumnSeries stackedColumnSeries = new StackedColumnSeries()
{
DataLabels = true,
Values = new ChartValues <double>()
};
List <Series> stackedColumnSeriesList = new List <Series>();
stackedColumnSeriesList.Add(stackedColumnSeries);
return(new Tuple <Axis, Axis, List <Series> >(
OrdinateAxis,
AbscissaAxis,
stackedColumnSeriesList));
case "Stacked Area":
StackedAreaSeries stackedAreaSeries = new StackedAreaSeries()
{
DataLabels = true,
Values = new ChartValues <DateTimePoint>()
};
List <Series> stackedAreaSeriesList = new List <Series>();
stackedAreaSeriesList.Add(stackedAreaSeries);
return(new Tuple <Axis, Axis, List <Series> >(
OrdinateAxis,
AbscissaAxis,
stackedAreaSeriesList));
case "Line":
LineSeries lineSeries = new LineSeries()
{
Title = "GeneratorOn (hrs)",
DataLabels = true,
Values = new ChartValues <double>()
};
List <Series> lineSeriesList = new List <Series>();
lineSeriesList.Add(lineSeries);
return(new Tuple <Axis, Axis, List <Series> >(
OrdinateAxis,
AbscissaAxis,
lineSeriesList));
case "Pie":
PieSeries pieSeries = new PieSeries()
{
Title = "GeneratorOn (hrs)",
DataLabels = true,
Values = new ChartValues <double>()
};
List <Series> pieSeriesList = new List <Series>();
pieSeriesList.Add(pieSeries);
return(new Tuple <Axis, Axis, List <Series> >(
OrdinateAxis,
AbscissaAxis,
pieSeriesList));
default:
break;
}
return(null);
}
public void AddLevel3Control(Point p)
{
switch (ControlTag)
{
case 31:
{
PieChart pieChart = new PieChart();
pieChart.Width = 400;
pieChart.Height = 300;
pieChart.LegendLocation = LegendLocation.Bottom;
PieSeries pieSeries = new PieSeries();
pieSeries.Values = new ChartValues <int> {
5
};
pieSeries.Title = "A";
pieSeries.DataLabels = true;
PieSeries pieSeries2 = new PieSeries();
pieSeries2.Values = new ChartValues <int> {
3
};
pieSeries2.Title = "B";
pieSeries2.DataLabels = true;
PieSeries pieSeries3 = new PieSeries();
pieSeries3.Values = new ChartValues <int> {
6
};
pieSeries3.Title = "C";
pieSeries3.DataLabels = true;
pieChart.Series.Add(pieSeries);
pieChart.Series.Add(pieSeries2);
pieChart.Series.Add(pieSeries3);
pieChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(pieChart, 0);
Canvas.SetLeft(pieChart, p.X - pieChart.DesiredSize.Width / 2);
Canvas.SetTop(pieChart, p.Y - pieChart.DesiredSize.Height / 2);
AddEvents(pieChart);
DesignCanvas.Children.Add(pieChart);
}
break;
case 32:
{
CartesianChart cartesianChart = new CartesianChart();
cartesianChart.Width = 400;
cartesianChart.Height = 300;
cartesianChart.LegendLocation = LegendLocation.Bottom;
ColumnSeries columnSeries = new ColumnSeries();
columnSeries.Values = new ChartValues <int> {
5
};
columnSeries.Title = "A";
columnSeries.DataLabels = true;
ColumnSeries columnSeries2 = new ColumnSeries();
columnSeries2.Values = new ChartValues <int> {
3
};
columnSeries2.Title = "B";
columnSeries2.DataLabels = true;
ColumnSeries columnSeries3 = new ColumnSeries();
columnSeries3.Values = new ChartValues <int> {
6
};
columnSeries3.Title = "C";
columnSeries3.DataLabels = true;
cartesianChart.Series.Add(columnSeries);
cartesianChart.Series.Add(columnSeries2);
cartesianChart.Series.Add(columnSeries3);
cartesianChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(cartesianChart, 0);
Canvas.SetLeft(cartesianChart, p.X - cartesianChart.DesiredSize.Width / 2);
Canvas.SetTop(cartesianChart, p.Y - cartesianChart.DesiredSize.Height / 2);
AddEvents(cartesianChart);
DesignCanvas.Children.Add(cartesianChart);
}
break;
case 33:
{
CartesianChart cartesianChart = new CartesianChart();
cartesianChart.Width = 400;
cartesianChart.Height = 300;
cartesianChart.LegendLocation = LegendLocation.Bottom;
StackedColumnSeries columnSeries = new StackedColumnSeries();
columnSeries.Values = new ChartValues <int> {
5, 6, 5
};
columnSeries.Title = "A";
columnSeries.DataLabels = true;
StackedColumnSeries columnSeries2 = new StackedColumnSeries();
columnSeries2.Values = new ChartValues <int> {
3, 4, 2
};
columnSeries2.Title = "B";
columnSeries2.DataLabels = true;
StackedColumnSeries columnSeries3 = new StackedColumnSeries();
columnSeries3.Values = new ChartValues <int> {
6, 3, 3
};
columnSeries3.Title = "C";
columnSeries3.DataLabels = true;
cartesianChart.Series.Add(columnSeries);
cartesianChart.Series.Add(columnSeries2);
cartesianChart.Series.Add(columnSeries3);
cartesianChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(cartesianChart, 0);
Canvas.SetLeft(cartesianChart, p.X - cartesianChart.DesiredSize.Width / 2);
Canvas.SetTop(cartesianChart, p.Y - cartesianChart.DesiredSize.Height / 2);
AddEvents(cartesianChart);
DesignCanvas.Children.Add(cartesianChart);
}
break;
case 34:
{
CartesianChart cartesianChart = new CartesianChart();
cartesianChart.Width = 400;
cartesianChart.Height = 300;
cartesianChart.LegendLocation = LegendLocation.Bottom;
RowSeries CarSeries = new RowSeries();
CarSeries.Values = new ChartValues <int> {
5
};
CarSeries.Title = "A";
CarSeries.DataLabels = true;
RowSeries CarSeries2 = new RowSeries();
CarSeries2.Values = new ChartValues <int> {
3
};
CarSeries2.Title = "B";
CarSeries2.DataLabels = true;
RowSeries CarSeries3 = new RowSeries();
CarSeries3.Values = new ChartValues <int> {
6
};
CarSeries3.Title = "C";
CarSeries3.DataLabels = true;
cartesianChart.Series.Add(CarSeries);
cartesianChart.Series.Add(CarSeries2);
cartesianChart.Series.Add(CarSeries3);
cartesianChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(cartesianChart, 0);
Canvas.SetLeft(cartesianChart, p.X - cartesianChart.DesiredSize.Width / 2);
Canvas.SetTop(cartesianChart, p.Y - cartesianChart.DesiredSize.Height / 2);
AddEvents(cartesianChart);
DesignCanvas.Children.Add(cartesianChart);
}
break;
case 35:
{
CartesianChart cartesianChart = new CartesianChart();
cartesianChart.Width = 400;
cartesianChart.Height = 300;
cartesianChart.LegendLocation = LegendLocation.Bottom;
StackedRowSeries columnSeries = new StackedRowSeries();
columnSeries.Values = new ChartValues <int> {
5, 6, 5
};
columnSeries.Title = "A";
columnSeries.DataLabels = true;
StackedRowSeries columnSeries2 = new StackedRowSeries();
columnSeries2.Values = new ChartValues <int> {
3, 4, 2
};
columnSeries2.Title = "B";
columnSeries2.DataLabels = true;
StackedRowSeries columnSeries3 = new StackedRowSeries();
columnSeries3.Values = new ChartValues <int> {
6, 3, 3
};
columnSeries3.Title = "C";
columnSeries3.DataLabels = true;
cartesianChart.Series.Add(columnSeries);
cartesianChart.Series.Add(columnSeries2);
cartesianChart.Series.Add(columnSeries3);
cartesianChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(cartesianChart, 0);
Canvas.SetLeft(cartesianChart, p.X - cartesianChart.DesiredSize.Width / 2);
Canvas.SetTop(cartesianChart, p.Y - cartesianChart.DesiredSize.Height / 2);
AddEvents(cartesianChart);
DesignCanvas.Children.Add(cartesianChart);
}
break;
case 36:
{
CartesianChart lineChart = new CartesianChart();
lineChart.Width = 400;
lineChart.Height = 300;
lineChart.LegendLocation = LegendLocation.Bottom;
LineSeries lineSeries = new LineSeries();
lineSeries.Values = new ChartValues <int> {
5, 6, 8
};
lineSeries.Title = "A";
lineSeries.DataLabels = true;
LineSeries lineSeries2 = new LineSeries();
lineSeries2.Values = new ChartValues <int> {
3, 2, 5
};
lineSeries2.Title = "B";
lineSeries2.DataLabels = true;
LineSeries lineSeries3 = new LineSeries();
lineSeries3.Values = new ChartValues <int> {
6, 5, 3
};
lineSeries3.Title = "C";
lineSeries3.DataLabels = true;
lineChart.Series.Add(lineSeries);
lineChart.Series.Add(lineSeries2);
lineChart.Series.Add(lineSeries3);
lineChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(lineChart, 0);
Canvas.SetLeft(lineChart, p.X - lineChart.DesiredSize.Width / 2);
Canvas.SetTop(lineChart, p.Y - lineChart.DesiredSize.Height / 2);
AddEvents(lineChart);
DesignCanvas.Children.Add(lineChart);
}
break;
case 37:
{
CartesianChart cartesianChart = new CartesianChart();
cartesianChart.Width = 400;
cartesianChart.Height = 300;
cartesianChart.LegendLocation = LegendLocation.Bottom;
StackedAreaSeries columnSeries = new StackedAreaSeries();
columnSeries.Values = new ChartValues <int> {
2, 4, 6
};
columnSeries.Title = "A";
columnSeries.DataLabels = true;
StackedAreaSeries columnSeries2 = new StackedAreaSeries();
columnSeries2.Values = new ChartValues <int> {
3, 5, 7
};
columnSeries2.Title = "B";
columnSeries2.DataLabels = true;
StackedAreaSeries columnSeries3 = new StackedAreaSeries();
columnSeries3.Values = new ChartValues <int> {
4, 6, 8
};
columnSeries3.Title = "C";
columnSeries3.DataLabels = true;
cartesianChart.Series.Add(columnSeries);
cartesianChart.Series.Add(columnSeries2);
cartesianChart.Series.Add(columnSeries3);
cartesianChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(cartesianChart, 0);
Canvas.SetLeft(cartesianChart, p.X - cartesianChart.DesiredSize.Width / 2);
Canvas.SetTop(cartesianChart, p.Y - cartesianChart.DesiredSize.Height / 2);
AddEvents(cartesianChart);
DesignCanvas.Children.Add(cartesianChart);
}
break;
case 38:
{
CartesianChart cartesianChart = new CartesianChart();
cartesianChart.Width = 400;
cartesianChart.Height = 300;
cartesianChart.LegendLocation = LegendLocation.Bottom;
StepLineSeries columnSeries = new StepLineSeries();
columnSeries.Values = new ChartValues <int> {
1, 2, 1
};
columnSeries.Title = "A";
columnSeries.DataLabels = true;
StepLineSeries columnSeries2 = new StepLineSeries();
columnSeries2.Values = new ChartValues <int> {
3, 5, 6
};
columnSeries2.Title = "B";
columnSeries2.DataLabels = true;
StepLineSeries columnSeries3 = new StepLineSeries();
columnSeries3.Values = new ChartValues <int> {
6, 7, 7
};
columnSeries3.Title = "C";
columnSeries3.DataLabels = true;
cartesianChart.Series.Add(columnSeries);
cartesianChart.Series.Add(columnSeries2);
cartesianChart.Series.Add(columnSeries3);
cartesianChart.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
Panel.SetZIndex(cartesianChart, 0);
Canvas.SetLeft(cartesianChart, p.X - cartesianChart.DesiredSize.Width / 2);
Canvas.SetTop(cartesianChart, p.Y - cartesianChart.DesiredSize.Height / 2);
AddEvents(cartesianChart);
DesignCanvas.Children.Add(cartesianChart);
}
break;
}
}
private void dataGrid_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
dynamic selectedItem = dataGrid.SelectedItems[0];
waterfallFlow.Children.Clear();
Series series = new ColumnSeries();
switch (FindElement.Settings.ChartType ?? 0)
{
case 0:
series = new ColumnSeries {
};
break;
case 1:
series = new StackedColumnSeries {
};
break;
case 2:
series = new LineSeries {
};
break;
case 3:
series = new StepLineSeries {
};
break;
case 4:
series = new StackedAreaSeries {
};
break;
}
getStudentScore(selectedItem.Id); // get Student scores
//get scores merge duplicates and replace string to int
var score = _initialCollection.GroupBy(x => new { x.Book, x.Date, x.StudentId })
.Select(x => new
{
x.Key.StudentId,
x.Key.Book,
x.Key.Date,
Sum = x.Sum(y => AppVariable.EnumToNumber(y.Scores))
}).ToArray();
//get Book Count for generate chart
var bookCount = score.GroupBy(x => new { x.Book })
.Select(g => new
{
g.Key.Book
}).ToList();
MaterialChart _addUser;
Control _currentUser;
//generate chart based on count of books
foreach (var item in bookCount)
{
_addUser = new MaterialChart(item.Book, selectedItem.Name + " " + selectedItem.LName, getDateArray(item.Book), getScoreArray(item.Book), getAverage(item.Book), getAverageStatus(item.Book), series, AppVariable.GetBrush(FindElement.Settings.ChartColor ?? AppVariable.CHART_GREEN));
_currentUser = _addUser;
waterfallFlow.Children.Add(_currentUser);
}
waterfallFlow.Refresh();
}
catch (ArgumentNullException) { }
catch (NullReferenceException)
{
}
}
/// <summary>
/// Format the series based on the particular coin
/// </summary>
/// <param name="MinerPaymentSummary"></param>
/// <param name="stackedColumnSeries"></param>
private static void FormatChartSeries(MinerPaymentSummary MinerPaymentSummary, StackedAreaSeries stackedColumnSeries)
{
// Series color
var converter = new System.Windows.Media.BrushConverter();
CoinPaymentChartColor.CoinPaymentChartColorDictionary.TryGetValue(MinerPaymentSummary.CoinType, out string chartColor);
Brush brushFill = (Brush)converter.ConvertFromString(chartColor);
brushFill.Opacity = 0.05;
Brush brushStroke = (Brush)converter.ConvertFromString(chartColor);
brushStroke.Opacity = 1;
stackedColumnSeries.Title = MinerPaymentSummary.CoinType.ToString();
stackedColumnSeries.LineSmoothness = 0.7;
stackedColumnSeries.PointGeometrySize = 6;
stackedColumnSeries.Fill = brushFill;
stackedColumnSeries.Stroke = brushStroke;
stackedColumnSeries.StrokeThickness = 1;
}
private Dictionary <string, object> CodigoDeAdomd2DimensionSA(string query)
{
Dictionary <string, object> resultado = new Dictionary <string, object>();
AdomdConnection con = new AdomdConnection("Data Source=DESKTOP-MF82JHU;catalog=FullOlapCube");
con.Open();
AdomdCommand cmd = new AdomdCommand(query, con);
CellSet cs = cmd.ExecuteCellSet();
TupleCollection tuplesOnColumns = cs.Axes[0].Set.Tuples;
Microsoft.AnalysisServices.AdomdClient.Tuple tp = cs.Axes[1].Set.Tuples[1];
string tituloX = tp.Members[0].ParentLevel.Caption;
string tituloY = "";
foreach (Microsoft.AnalysisServices.AdomdClient.Tuple column in tuplesOnColumns)
{
tituloY = column.Members[0].Caption;
}
TupleCollection tuplesOnRows = cs.Axes[1].Set.Tuples;
//List<string> listaNombres = new List<string>();
//List<double> listaValores = new List<double>();
int row = 0;
int rowAux = 0;
List <LineSeries> seriesList = new List <LineSeries>();
List <string> seriesLabel = new List <string>();
//Convert cvv = new Convert();
while (row < tuplesOnRows.Count)
{
string firstCategory = tuplesOnRows[rowAux].Members[0].Caption;
StackedAreaSeries ls = new StackedAreaSeries();
ls.Title = firstCategory;
ChartValues <DateTimePoint> cv = new ChartValues <DateTimePoint>();
while (tuplesOnRows[row].Members[0].Caption == firstCategory)
{
//for (int members = 0; members < tuplesOnRows[row].Members.Count; members++)
//{
DateTimePoint dtp = new DateTimePoint();
dtp.DateTime = new DateTime(Convert.ToInt32(tuplesOnRows[row].Members[1].Caption), 1, 1);
seriesLabel.Add(tuplesOnRows[row].Members[1].Caption);
//}
for (int col = 0; col < tuplesOnColumns.Count; col++)
{
dtp.Value = Convert.ToDouble(cs.Cells[col, row].FormattedValue);
cv.Add(dtp);
//listaValores.Add(Convert.ToDouble(cs.Cells[col, row].FormattedValue));
}
row++;
if (row == tuplesOnRows.Count)
{
break;
}
}
ls.Values = cv;
rowAux = row;
seriesList.Add(ls);
}
con.Close();
resultado.Add("listaNombres", seriesLabel);
resultado.Add("listaValores", seriesList);
resultado.Add("tituloX", tituloX);
resultado.Add("tituloY", tituloY);
return(resultado);
}
void Update()
{
chart.Series.Clear();
for (int r = 0; r < dt.Rows.Count; r++)
{
Series CSeries;
if (Ctype == ChartType.Chart_Type.PieChart)
{
CSeries = new PieSeries();
}
else if (Ctype == ChartType.Chart_Type.ColumnChart)
{
CSeries = new ColumnSeries();
}
else if (Ctype == ChartType.Chart_Type.RowChart)
{
CSeries = new RowSeries();
}
else if (Ctype == ChartType.Chart_Type.StackedColumnChart)
{
CSeries = new StackedColumnSeries();
}
else if (Ctype == ChartType.Chart_Type.StackedRowChart)
{
CSeries = new StackedRowSeries();
}
else if (Ctype == ChartType.Chart_Type.StackedAreaChart)
{
CSeries = new StackedAreaSeries();
}
else if (Ctype == ChartType.Chart_Type.StepLineChart)
{
CSeries = new StepLineSeries();
}
else
{
CSeries = new LineSeries();
}
CSeries.Values = new ChartValues <double> {
};
for (int c = 0; c < dt.Columns.Count; c++)
{
// Debug.WriteLine(dt.Rows[r].Field<double?>(c));
if (dt.Rows[r].Field <double?>(c) != null)
{
CSeries.Values.Add(dt.Rows[r].Field <double>(c));
}
}//columns
if (r < ListBox_Customization.Items.Count)
{
StackPanel panel = (StackPanel)ListBox_Customization.Items[r];
CSeries.Title = ((TextBox)panel.Children[0]).Text;
CSeries.DataLabels = (((CheckBox)panel.Children[1]).IsChecked == true);
double size = 10;
if (double.TryParse(((TextBox)panel.Children[2]).Text, out size) == false)
{
size = 10;
}
CSeries.FontSize = size;
CSeries.Stroke = ((Rectangle)((StackPanel)panel.Children[3]).Children[0]).Fill;
double sth = 0;
if (double.TryParse(((TextBox)panel.Children[4]).Text, out sth))
{
CSeries.StrokeThickness = sth;
}
/*
* if ((((CheckBox)panel.Children[4]).IsChecked == true))
* CSeries.Fill = ((Rectangle)((StackPanel)panel.Children[5]).Children[0]).Fill;
* else
* CSeries.Fill = null;*/
}
else
{
CSeries.Title = "R" + r;
CSeries.DataLabels = true;
}
chart.Series.Add(CSeries);
}//rows
if (RB_CusColors.IsChecked == true)
{
ColorsCollection colorsCollection = new ColorsCollection();
for (int i = 0; i < ListBox_Colors.Items.Count; i++)
{
StackPanel stack = (StackPanel)ListBox_Colors.Items[i];
colorsCollection.Add(((SolidColorBrush)((Rectangle)stack.Children[0]).Fill).Color);
}
chart.SeriesColors = colorsCollection;
}
else
{
chart.SeriesColors = null;
}
}
public void SetLineSeries(DataPtSet PollenDataSet, SeriesChartType ChartMode)
{
DataList = PollenDataSet;
ChartType = ChartMode;
List <double> DbList = new List <double>();
LineSeries tLineSeries = new LineSeries();
StackedAreaSeries tAreaSeries = new StackedAreaSeries();
tLineSeries.PointGeometry = DefaultGeometries.None;
tLineSeries.Fill = null;
tAreaSeries.PointGeometry = DefaultGeometries.None;
tAreaSeries.Fill = null;
tLineSeries = (SetProperties(tLineSeries, DataList.Points[0]));
tAreaSeries = (SetProperties(tAreaSeries, DataList.Points[0]));
switch (ChartType)
{
case SeriesChartType.Point:
ChartSequence = (SetProperties(tLineSeries, DataList.Points[0]));
foreach (DataPt D in DataList.Points)
{
LineSeries NewSeries = new LineSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.Line:
tLineSeries.Fill = Brushes.Transparent;
tLineSeries.LineSmoothness = 0;
ChartSequence = tLineSeries;
foreach (DataPt D in DataList.Points)
{
DbList.Add(D.Number);
LineSeries NewSeries = new LineSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.Spline:
tLineSeries.Fill = Brushes.Transparent;
ChartSequence = tLineSeries;
foreach (DataPt D in DataList.Points)
{
LineSeries NewSeries = new LineSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.StepLine:
StepLineSeries StepSeries = new StepLineSeries();
StepSeries.AlternativeStroke = DataList.Points[0].Graphics.GetStrokeBrush();
StepSeries = SetProperties(StepSeries, DataList.Points[0]);
ChartSequence = StepSeries;
foreach (DataPt D in DataList.Points)
{
StepLineSeries NewSeries = new StepLineSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.Area:
ChartSequence = tLineSeries;
foreach (DataPt D in DataList.Points)
{
LineSeries NewSeries = new LineSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.AreaStack:
tAreaSeries.LineSmoothness = 0;
ChartSequence = tAreaSeries;
foreach (DataPt D in DataList.Points)
{
StackedAreaSeries NewSeries = new StackedAreaSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.AreaStack100:
tAreaSeries.LineSmoothness = 0;
tAreaSeries.StackMode = StackMode.Percentage;
ChartSequence = tAreaSeries;
foreach (DataPt D in DataList.Points)
{
StackedAreaSeries NewSeries = new StackedAreaSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.SplineArea:
ChartSequence = tLineSeries;
foreach (DataPt D in DataList.Points)
{
LineSeries NewSeries = new LineSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.SplineAreaStack:
ChartSequence = tAreaSeries;
foreach (DataPt D in DataList.Points)
{
StackedAreaSeries NewSeries = new StackedAreaSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
case SeriesChartType.SplineAreaStack100:
tAreaSeries.StackMode = StackMode.Percentage;
ChartSequence = tAreaSeries;
foreach (DataPt D in DataList.Points)
{
StackedAreaSeries NewSeries = new StackedAreaSeries {
Values = new ChartValues <double> {
D.Number
}
};
NewSeries = SetProperties(NewSeries, D);
DbList.Add(D.Number);
ChartSeries.Add(NewSeries);
}
break;
}
ChartSequence.Values = new ChartValues <double>(DbList.ToArray());
//Set unique properties of the control
}
private void cmbAzmon_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
gpChart.Visibility = Visibility.Visible;
double[] values = new double[] { };
try
{
dynamic getGroupName = cmbGroups.SelectedItem;
string gpName = getGroupName.GroupName;
dynamic getDateText = cmbAzmon.SelectedItem;
string dPass = getDateText.DatePass;
using (var db = new DataClass.myDbContext())
{
dynamic selectedItem = dataGrid.SelectedItems[0];
long uId = selectedItem.Id;
var data = db.AHistories.Where(x => x.UserId == uId && x.DatePass == dPass && x.GroupName.Equals(gpName)).Select(x => x).OrderByDescending(x => x.DatePass).ToList();
values = new double[] { data.FirstOrDefault().TrueItem, data.FirstOrDefault().FalseItem, data.FirstOrDefault().NoneItem };
Series series = new ColumnSeries();
switch (FindElement.Settings.ChartType ?? 0)
{
case 0:
series = new ColumnSeries {
};
break;
case 1:
series = new StackedColumnSeries {
};
break;
case 2:
series = new LineSeries {
};
break;
case 3:
series = new StepLineSeries {
};
break;
case 4:
series = new StackedAreaSeries {
};
break;
}
if (series.GetType() == typeof(ColumnSeries))
{
AchievementChart.Series.Add(new ColumnSeries
{
Values = new ChartValues <double>(values),
StrokeDashArray = new System.Windows.Media.DoubleCollection(20)
});
}
else if (series.GetType() == typeof(LineSeries))
{
AchievementChart.Series.Add(new LineSeries
{
Values = new ChartValues <double>(values),
StrokeDashArray = new System.Windows.Media.DoubleCollection(20)
});
}
else if (series.GetType() == typeof(StackedAreaSeries))
{
AchievementChart.Series.Add(new StackedAreaSeries
{
Values = new ChartValues <double>(values),
StrokeDashArray = new System.Windows.Media.DoubleCollection(20)
});
}
else if (series.GetType() == typeof(StackedColumnSeries))
{
AchievementChart.Series.Add(new StackedColumnSeries
{
Values = new ChartValues <double>(values),
StrokeDashArray = new System.Windows.Media.DoubleCollection(20)
});
}
else if (series.GetType() == typeof(StepLineSeries))
{
AchievementChart.Series.Add(new StepLineSeries
{
Values = new ChartValues <double>(values),
StrokeDashArray = new System.Windows.Media.DoubleCollection(20)
});
}
AchievementChart.AxisX.Add(new Axis
{
Labels = new string[] { "پاسخ صحیح", "پاسخ غلط", "بدون پاسخ" },
Separator = new LiveCharts.Wpf.Separator {
}
});
txtName.Text = dPass;
txtBook.Text = gpName;
}
}
catch (Exception)
{
}
}
//AREA STACK CHART #########################################################################################################################
public void SetStackAreaChart(bool IsStretched, int Smoothness)
{
if (IsStretched)
{
if (ChartType != SeriesChartType.AreaStack100)
{
Element.Series.Clear();
}
ChartType = SeriesChartType.AreaStack100;
}
else
{
if (ChartType != SeriesChartType.AreaStack)
{
Element.Series.Clear();
}
ChartType = SeriesChartType.AreaStack;
}
List <List <double> > DV = new List <List <double> >();
//Populate Data Set
for (int i = 0; i < DataGrid.Sets.Count; i++)
{
List <double> tDV = new List <double>();
for (int j = 0; j < DataGrid.Sets[i].Points.Count; j++)
{
tDV.Add(DataGrid.Sets[i].Points[j].Number);
}
DV.Add(tDV);
}
int C = Element.Series.Count;
int S = DV.Count;
for (int i = C; i < S; i++)
{
StackedAreaSeries CS = new StackedAreaSeries();
CS.LineSmoothness = Smoothness;
if (IsStretched)
{
CS.StackMode = StackMode.Percentage;
}
else
{
CS.StackMode = StackMode.Values;
}
Element.Series.Add(CS);
Element.Series[i].Values = new ChartValues <double>(DV[i].ToArray());
}
C = Element.Series.Count;
if (C > S)
{
for (int i = S; i < C; i++)
{
Element.Series.RemoveAt(Element.Series.Count - 1);
}
}
C = Element.Series.Count;
for (int i = 0; i < S; i++)
{
int T = Element.Series[i].Values.Count;
int V = DV[i].Count;
for (int j = T; j < V; j++)
{
Element.Series[i].Values.Add(1.0);
}
}
for (int i = 0; i < S; i++)
{
int T = Element.Series[i].Values.Count;
int V = DV[i].Count;
if (T > V)
{
for (int j = V; j < T; j++)
{
Element.Series[i].Values.RemoveAt(Element.Series[i].Values.Count - 1);
}
}
}
for (int i = 0; i < S; i++)
{
int V = DV[i].Count;
for (int j = 0; j < V; j++)
{
Element.Series[i].Values[j] = DV[i][j];
SetStackAreaProperties((StackedAreaSeries)Element.Series[i], DataGrid.Sets[i].Points[j]);
SetSequenceProperties(i, j, (StackedAreaSeries)Element.Series[i]);
}
}
}
public void DiagrammInit()
{
string[] SeriesTitle = new string[] { "Потребл", "Продажа", "Потери" };
int i = 0;
int dlina = MonthUseList.Count();
SeriesCollection.Clear();
StackedAreaSeries ls1 = new StackedAreaSeries
{
Title = SeriesTitle[i],
LineSmoothness = 0,
DataLabels = true,
StrokeThickness = 2.5,
//Stroke = System.Windows.Media.Brushes.DeepSkyBlue,
Fill = System.Windows.Media.Brushes.AliceBlue,
FontSize = 10,
Foreground = System.Windows.Media.Brushes.Black,
FontWeight = FontWeights.Bold,
LabelPoint = point => string.Format("{0:N0}", point.Y),
Values = new ChartValues <ObservableValue>(ValueYFill(SeriesTitle[i]))
};
StackedAreaSeries ls2 = new StackedAreaSeries
{
Title = SeriesTitle[i + 1],
LineSmoothness = 0,
DataLabels = true,
StrokeThickness = 2.5,
//Stroke = System.Windows.Media.Brushes.Red,
Fill = System.Windows.Media.Brushes.Pink,
FontSize = 10,
Foreground = System.Windows.Media.Brushes.Black,
FontWeight = FontWeights.Bold,
LabelPoint = point => string.Format("{0:N0}", point.Y),
Values = new ChartValues <ObservableValue>(ValueYFill(SeriesTitle[i + 1]))
};
StackedAreaSeries ls3 = new StackedAreaSeries
{
Title = SeriesTitle[i + 2],
LineSmoothness = 0,
DataLabels = true,
FontSize = 10,
StrokeThickness = 2.5,
Foreground = System.Windows.Media.Brushes.Black,
Stroke = System.Windows.Media.Brushes.DarkRed,
Fill = System.Windows.Media.Brushes.Moccasin,
FontWeight = FontWeights.Bold,
LabelPoint = point => string.Format("{0:N0}", point.Y),
AreaLimit = 0,
Values = new ChartValues <ObservableValue>(ValueYFill(SeriesTitle[i + 2]))
};
SeriesCollection.Add(ls1);
SeriesCollection.Add(ls2);
SeriesCollection.Add(ls3);
Labels.Clear();
foreach (var newX in MonthUseList)
{
Labels.Add(newX.Period.ToString());
}
;
//Labels.Clear();
//Labels = ObservableCollection<string>(MonthUseList.Select(x => x.Period));
ChartValues <ObservableValue> ValueYFill(string typeSeries = "")
{
ChartValues <ObservableValue> rez = new ChartValues <ObservableValue>();
switch (typeSeries)
{
case ("Потребл"):
foreach (ViewFabricateUse newY in MonthUseList)
{
rez.Add(new ObservableValue(newY.Fact1));
}
break;
case ("Продажа"):
foreach (ViewFabricateUse newY in MonthUseList)
{
rez.Add(new ObservableValue(newY.Fact0));
}
break;
case ("Потери"):
foreach (ViewFabricateUse newY in MonthUseList)
{
rez.Add(new ObservableValue(newY.Loss));
}
break;
}
return(rez);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="info">The information about COVID19 for each country.</param>
public CountryView(IReadOnlyList <CountryInfoEx> info)
{
const long animationSpeedGraph = 0;
const long animationSpeedGauge = 5000000;
IReadOnlyList <CountryInfoEx> countries = info;
// information used for normalize
CountryInfoEx _mostConfirmed;
CountryInfoEx _mostDeaths;
CountryInfoEx _mostRecovered;
_startDate = countries[0].DaysInfo[0].Date.ToDateTime();
NumberOfDays = countries[0].DaysInfo.Count;
_mostConfirmed = Utils.MaxElement(countries, (CountryInfoEx a, CountryInfoEx b) => a.Confirmed > b.Confirmed);
_mostDeaths = Utils.MaxElement(countries, (CountryInfoEx a, CountryInfoEx b) => a.Deaths > b.Deaths);
_mostRecovered = Utils.MaxElement(countries, (CountryInfoEx a, CountryInfoEx b) => a.Recovered > b.Recovered);
_confirmed = new long[NumberOfDays];
_deaths = new long[NumberOfDays];
_recovered = new long[NumberOfDays];
// build the chart with numbers of infected people
_stackedAreaRecovered = new StackedAreaSeries
{
Title = "Recovered",
Values = GetRegionChartValues(new long[1], _startDate),
LineSmoothness = 0
};
_stackedAreaDead = new StackedAreaSeries
{
Title = "Deaths",
Values = GetRegionChartValues(new long[1], _startDate),
LineSmoothness = 0
};
_stackedAreaConfirmed = new StackedAreaSeries
{
Title = "Active",
Values = GetRegionChartValues(new long[1], _startDate),
LineSmoothness = 0
};
_stackedAreaRecovered.Fill = System.Windows.Media.Brushes.MediumSeaGreen;
_stackedAreaDead.Fill = System.Windows.Media.Brushes.Crimson;
_stackedAreaConfirmed.Fill = System.Windows.Media.Brushes.Gold;
_cartesianChartRegions.Series = new SeriesCollection
{
_stackedAreaDead,
_stackedAreaConfirmed,
_stackedAreaRecovered,
};
_cartesianChartRegions.AnimationsSpeed = new TimeSpan(animationSpeedGraph);
_solidGaugeDeathRate.AnimationsSpeed = new TimeSpan(animationSpeedGauge);
_solidGaugeInfectionRage.AnimationsSpeed = new TimeSpan(animationSpeedGauge);
_solidGaugeRecoveryRate.AnimationsSpeed = new TimeSpan(animationSpeedGauge);
_cartesianChartRegions.AxisX.Add(new Axis
{
LabelFormatter = value => new DateTime((long)value).ToString("dd-MMM")
});
_cartesianChartRegions.AxisY.Add(new Axis
{
Title = "Number of people",
LabelFormatter = value => ((long)value).ToString("N0")
});
_cartesianChartRegions.LegendLocation = LegendLocation.Right;
// build the solid gauge for confirmed infected people rate
_solidGaugeInfectionRage.From = 0;
_solidGaugeInfectionRage.To = Math.Log(_mostConfirmed.Confirmed);
_solidGaugeInfectionRage.Value = 0;
_solidGaugeInfectionRage.Base.LabelsVisibility = Visibility.Hidden;
_solidGaugeInfectionRage.LabelFormatter = value => value.ToString();
_solidGaugeInfectionRage.Base.GaugeActiveFill = new LinearGradientBrush
{
GradientStops = new GradientStopCollection
{
new GradientStop(Colors.DarkOrange, 0),
new GradientStop(Colors.Gold, 0.5),
new GradientStop(Colors.Yellow, 1)
}
};
// build the solid gauge for death rate
_solidGaugeDeathRate.From = 0;
_solidGaugeDeathRate.To = Math.Log(_mostDeaths.Deaths);
_solidGaugeDeathRate.Value = 0;
_solidGaugeDeathRate.Base.LabelsVisibility = Visibility.Hidden;
_solidGaugeDeathRate.LabelFormatter = value => value.ToString();
_solidGaugeDeathRate.Base.GaugeActiveFill = new LinearGradientBrush
{
GradientStops = new GradientStopCollection
{
new GradientStop(Colors.Firebrick, 0),
new GradientStop(Colors.Crimson, 0.5),
new GradientStop(Colors.Red, 1)
}
};
// build the solid gauge for recovery rate
_solidGaugeRecoveryRate.From = 0;
_solidGaugeRecoveryRate.To = Math.Log(_mostRecovered.Recovered);
_solidGaugeRecoveryRate.Value = 0;
_solidGaugeRecoveryRate.Base.LabelsVisibility = Visibility.Hidden;
_solidGaugeRecoveryRate.LabelFormatter = value => value.ToString();
_solidGaugeRecoveryRate.Base.GaugeActiveFill = new LinearGradientBrush
{
GradientStops = new GradientStopCollection
{
new GradientStop(Colors.DarkGreen, 0),
new GradientStop(Colors.MediumSeaGreen, 0.5),
new GradientStop(Colors.Chartreuse, 1)
}
};
// buid the page layout as a table layout
_tableLayoutPanel.Dock = DockStyle.Fill;
_tableLayoutPanel.RowCount = 3;
_tableLayoutPanel.ColumnCount = 3;
_tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10));
_tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 60));
_tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 30));
_tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10));
_tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33));
_tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33));
_tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33));
// row 0
Font fontTitle = new Font("Microsoft Sans Serif", 15F, System.Drawing.FontStyle.Bold);
_labelTitle = new Label
{
Text = "",
AutoSize = true,
Font = fontTitle,
Anchor = AnchorStyles.None
};
_tableLayoutPanel.Controls.Add(_labelTitle, 1, 0);
// row 1
_tableLayoutPanel.Controls.Add(_cartesianChartRegions, 0, 1);
_tableLayoutPanel.SetColumnSpan(_cartesianChartRegions, 3);
_cartesianChartRegions.Dock = DockStyle.Fill;
// row 2
_tableLayoutPanel.Controls.Add(_solidGaugeInfectionRage, 0, 2);
_solidGaugeInfectionRage.Anchor = AnchorStyles.None;
_tableLayoutPanel.Controls.Add(_solidGaugeDeathRate, 1, 2);
_solidGaugeDeathRate.Anchor = AnchorStyles.None;
_tableLayoutPanel.Controls.Add(_solidGaugeRecoveryRate, 2, 2);
_solidGaugeRecoveryRate.Anchor = AnchorStyles.None;
// row 3
Font font = new Font("Microsoft Sans Serif", 10F, System.Drawing.FontStyle.Bold);
_tableLayoutPanel.Controls.Add(new Label
{
Text = (_mostConfirmed.Confirmed > 1000000 ? $"Reference value: {Math.Round(_mostConfirmed.Confirmed / 1000000.0, 2)}M ({_mostConfirmed.Name})" :
$"Reference value: {Math.Round(_mostConfirmed.Confirmed / 1000.0, 2)}K ({_mostConfirmed.Name})"),
AutoSize = true,
Font = font,
Anchor = AnchorStyles.None
}, 0, 3);
_tableLayoutPanel.Controls.Add(new Label
{
Text = (_mostDeaths.Deaths > 1000000 ? $"Reference value: {Math.Round(_mostDeaths.Deaths / 1000000.0, 2)}M ({_mostDeaths.Name})" :
$"Reference value: {Math.Round(_mostDeaths.Deaths / 1000.0, 2)}K ({_mostDeaths.Name})"),
AutoSize = true,
Font = font,
Anchor = AnchorStyles.None
}, 1, 3);
_tableLayoutPanel.Controls.Add(new Label
{
Text = (_mostRecovered.Recovered > 1000000 ? $"Reference value: {Math.Round(_mostRecovered.Recovered / 1000000.0, 2)}M ({_mostRecovered.Name})" :
$"Reference value: {Math.Round(_mostRecovered.Recovered / 1000.0, 2)}K ({_mostRecovered.Name})"),
AutoSize = true,
Font = font,
Anchor = AnchorStyles.None
}, 2, 3);
_tabPage.Padding = new Padding(30);
_tabPage.Controls.Add(_tableLayoutPanel);
UpdateChart(_mostConfirmed);
}
private void difference_Click(object sender, EventArgs e)
{
cartesianChart1.Series.Clear();
Dictionary <string, string> dictionary = new Dictionary <string, string>();
dictionary.Add("Municipios", citiesComboBox.Text);
dm.filterDataForHarvested(dictionary);
SeriesCollection harvestedSerie = new SeriesCollection();
StackedAreaSeries hSerie = new StackedAreaSeries();
StackedAreaSeries pSerie = new StackedAreaSeries();
hSerie.Title = "Harvested";
pSerie.Title = "Planted";
ChartValues <ScatterPoint> cvalues = new ChartValues <ScatterPoint>();
ScatterPoint pair;
foreach (CropMeasurement cm in dm.Harvested)
{
if (cm.A_o >= 2011 && cm.A_o <= 2017)
{
pair = new ScatterPoint(cm.A_o, cm.getTypeCrop(cropCombobox.Text));
cvalues.Add(pair);
}
}
hSerie.Values = cvalues;
hSerie.LineSmoothness = 0;
dm.filterDataForPlanted(dictionary);
ChartValues <ScatterPoint> cvalues2 = new ChartValues <ScatterPoint>();
ScatterPoint pair2;
foreach (CropMeasurement cm in dm.Planted)
{
if (cm.A_o >= 2011 && cm.A_o <= 2017)
{
pair2 = new ScatterPoint(cm.A_o, cm.getTypeCrop(cropCombobox.Text));
cvalues2.Add(pair2);
}
}
pSerie.Values = cvalues2;
pSerie.LineSmoothness = 0;
harvestedSerie.Add(hSerie);
harvestedSerie.Add(pSerie);
cartesianChart1.Series = harvestedSerie;
cartesianChart1.AxisX = new AxesCollection
{
new Axis {
Title = "Date",
//LabelFormatter = value => new DateTime((long)value).ToShortDateString()
},
};
}
public void SetStackAreaProperties(StackedAreaSeries Ser, DataPt Pt)
{
Ser.PointForeground = Pt.Marker.Graphics.GetBackgroundBrush();
Ser.PointGeometrySize = Pt.Marker.Radius;
}
