/// <summary>
///
/// </summary>
/// <param name="error"></param>
/// <param name="context"></param>
public override void RenderError(Exception error, IMvcContext context)
{
var config = ChartConfig.Create(error);
var script = GetErrorChartContent(context, config);
context.StatusCode = 500;
context.Output.Write(script);
}
public static string GetChartConfigJSON(ChartConfig config)
{
return(JsonConvert.SerializeObject(config,
new JsonSerializerSettings()
{
NullValueHandling = NullValueHandling.Ignore
}));
}
public static void DrawChartGrid(ChartConfig config)
{
var baseX = config.Rect.x;
var baseY = config.Rect.y;
var w = config.Rect.width;
var h = config.Rect.height;
const float lineWidth = 1f;
var yStep = h / config.VerticalScale * config.VerticalMarkers;
var y = baseY;
var i = 0;
var lblStyle = new GUIStyle();
lblStyle.normal.textColor = Color.white;
while (y <= baseY + h)
{
var p1 = new Vector2(baseX, y);
var p2 = new Vector2(baseX + w, y);
Drawing.DrawLine(p1, p2, config.MarkerColor, lineWidth);
y += yStep;
if (i % 2 == 0)
{
var lbl = (config.VerticalScale - i * config.VerticalMarkers).ToString();
var lblRect = GUILayoutUtility.GetRect(new GUIContent(lbl), lblStyle);
GUI.Label(new Rect(p1.x - 10, p1.y - lblRect.height / 2f, lblRect.height, lblRect.width), lbl, lblStyle);
}
i++;
}
var xStep = w / config.HorizontalScale * config.HorizontalMarkers;
var x = baseX;
while (x <= baseX + w)
{
var p1 = new Vector2(x, baseY);
var p2 = new Vector2(x, baseY + h);
Drawing.DrawLine(p1, p2, config.MarkerColor, lineWidth);
x += xStep;
}
}
private IChartConfig PrepareChartConfig(IMvcContext context)
{
if (context.ActionResult is IChartConfig)
{
return(context.ActionResult as IChartConfig);
}
if (context.ActionResult is Exception)
{
return(ChartConfig.Create(context.ActionResult as Exception));
}
var result = new ChartConfig {
Id = context.Get("id", DateTime.Now.Ticks).ToString(CultureInfo.InvariantCulture),
Container = context.Get("container", string.Empty),
Width = context.Get("width", "400"),
Height = context.Get("height", "300"),
Debug = context.Get("debug", "0"),
Type = context.Get("type", "Column2D"),
Divlines = context.Get("divlines", -1)
};
var specAttrs = context.GetAll("fc");
foreach (var attr in specAttrs)
{
result.Set(attr.Key, attr.Value);
}
if (context.ActionResult is ChartState)
{
result.State = context.ActionResult as ChartState;
}
else
{
result.NativeResult = context.ActionResult;
}
return(result);
}
public void Display(ChartConfig config)
{
if (config == null)
{
throw new ArgumentException("Null Config");
}
chartTitle.Text = config.SectionTitle;
//Size
chartImage.Width = config.Size.Width;
chartImage.Height = config.Size.Height;
chartImage.AlternateText = "Chart: " + config.SectionTitle;
chartImage.BorderWidth = 0;
Dictionary <string, string> chartData = config.DataProvider.GetLookupData();
List <string> dataArray = new List <string>();
List <string> labelArray = new List <string>();
dataArray.AddRange(chartData.Values);
labelArray.AddRange(chartData.Keys);
StringBuilder sb = new StringBuilder();
sb.Append(config.BaseUrl);
sb.AppendFormat("cht={0}", config.Type);
sb.AppendFormat("&chs={0}x{1}", config.Size.Width, config.Size.Height);
sb.AppendFormat("&chd=t:{0}", string.Join(",", dataArray.ToArray()));
sb.AppendFormat("&chl={0}", string.Join("|", labelArray.ToArray()));
if (!string.IsNullOrEmpty(config.Color))
{
sb.AppendFormat("&chco={0}", config.Color);
}
chartImage.ImageUrl = sb.ToString();
}
public static void DrawChart(IEnumerable <float> values, ChartConfig config, Color?color = null)
{
color = color ?? Color.yellow;
var baseX = config.Rect.x;
var baseY = config.Rect.y;
var w = config.Rect.width;
var h = config.Rect.height;
const float lineWidth = 1f;
var previousPos = new Vector2(baseX, baseY + h);
var i = 1;
foreach (var val in values.Skip(1))
{
var x = baseX + i * (w / config.HorizontalScale);
var y = (baseY + h) - val * (h / config.VerticalScale);
var pos = new Vector2(x, y);
Drawing.DrawLine(previousPos, pos, color.Value, lineWidth);
previousPos = pos;
i++;
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static OpenFlashChart.OpenFlashChart Create(object dataSource, ChartConfig chartConfig)
{
return null;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
static public OpenFlashChart.OpenFlashChart Create(object dataSource, ChartConfig chartConfig)
{
return(null);
}
private void LoadChart(ChartConfig config)
{
var json = ChartBuilder.GetChartConfigJSON(config);
Eval($"loadChart({ json });");
}
public async Task <string> CreateChart(ChartConfig chartConfig)
{
var bytes = await imageChartGenerator.GenerateChartAsync(chartConfig);
return(Convert.ToBase64String(bytes));
}
public GraphDataCat(TimeSpan startTime, string title,
ChartConfig chartConfig, CatSelection catSelection)
{
_startTime = startTime;
this.Title = title;
_clipMax = chartConfig.ClipMax;
X = new LineSeries()
{
Title = "X",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0xff, 0, 0),
};
Y = new LineSeries()
{
Title = "Y",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0, 0xff, 0),
};
Z = new LineSeries()
{
Title = "Z",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0, 0, 0xff),
};
switch (catSelection)
{
case CatSelection.GroupByLinearAcceleration:
Axes.Add(new LinearAxis
{
Position = AxisPosition.Left,
Minimum = chartConfig.LinearAccelerationMin,
Maximum = chartConfig.LinearAccelerationMax,
});
break;
case CatSelection.GroupByAngularVelocity:
Axes.Add(new LinearAxis
{
Position = AxisPosition.Left,
Minimum = chartConfig.AngularVelocityMin,
Maximum = chartConfig.AngularVelocityMax,
});
break;
case CatSelection.GroupByAngle:
Axes.Add(new LinearAxis
{
Position = AxisPosition.Left,
Minimum = chartConfig.AngleMin,
Maximum = chartConfig.AngleMax,
});
break;
}
this.IsLegendVisible = true;
this.Series.Add(X);
this.Series.Add(Y);
this.Series.Add(Z);
//this.Series.Add(new FunctionSeries(Math.Cos, 0, 10, 0.1, "cos(x)"));
}
/// <summary>
/// Index function differentiates between showing results for just on process |processids| == 1,
/// and showing multiple processes at a time (always without regard to the actual occurrence time of the process)
/// </summary>
/// <param name="processids">list of processes to show</param>
/// <param name="precision">level of precision (compared to normalized View - [0,1]!)</param>
/// <param name="links">number of links('Glieder') we want our Envelope to have</param>
/// <param name="options">view options (which graphs should we draw?)</param>
/// <param name="par">dont know, never used this</param>
/// <returns></returns>
public ActionResult Index(int[] processids, decimal precision = 1m, int links = 5, string options = null, ChartParams par = null)
{
DataContainers.Clear();
DataContainers.EnvelopeLinks = links;
DataContainers.EnvelopePrecision = precision;
// Parameter
if (par == null)
{
par = new ChartParams(new List <ChartBlockParams>()
{
});
}
//view options
var viewOptions = new List <SwhkViewOptions>();
if (options != null)
{
string[] zw = options.Split('@');
for (int i = 0; i < zw.Length; i++)
{
viewOptions.Add((SwhkViewOptions)Enum.Parse(typeof(SwhkViewOptions), zw[i]));
}
}
if (viewOptions.Count == 0)
{
viewOptions.Add(SwhkViewOptions.Original);
}
if (processids == null && TempData["processids"] != null)
{
processids = (int[])TempData["processids"];
}
#if DEBUG
if (processids.Length > 5)
{
processids = processids.Take(5).ToArray();
}
#endif
//Chart-Config
ChartConfig chartConfig = new ChartConfig()
{
Name = "Test"
};
ChartArea area = new ChartArea()
{
Name = "Sollwerthüllkurve",
ChartType = (int)ChartType.Polyline,
Seq = 1
};
chartConfig.Areas.Add(area);
ChartBlockParams cbpar = new ChartBlockParams();
cbpar.Start = DateTime.Now - new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
TimeSpan maxTime = new TimeSpan(0L);
Random rand = new Random();
foreach (int processid in processids)
{
PredictiveProcessData process = GetProcessData(processid);
process.ViewOptions.AddRange(viewOptions);
if (process == null)
{
throw new ArgumentException("process-id not found!");
}
if ((viewOptions.Contains(SwhkViewOptions.Original)))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = processid,
PrecictiveProcessData = process,
Name = process.Name,
Seq = 1,
ChartDataSourceId = 1,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//if just one process id -> show some specifig graphs
if (processids.Length == 1)
{
//'Sollhüllwertkurve'
if (viewOptions.Contains(SwhkViewOptions.Envelope))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = processid,
PrecictiveProcessData = process,
Name = process.Name + "-envelope",
Seq = 2,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//nomalized graph
if (viewOptions.Contains(SwhkViewOptions.Normalized))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = processid,
PrecictiveProcessData = process,
Name = process.Name + "-normalized",
Seq = 3,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//lower bound
if (viewOptions.Contains(SwhkViewOptions.LowerBound))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = processid,
PrecictiveProcessData = process,
Name = process.Name + "-lower",
Seq = 4,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//upper bound
if (viewOptions.Contains(SwhkViewOptions.UpperBound))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = processid,
PrecictiveProcessData = process,
Name = process.Name + "-upper",
Seq = 5,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
}
if (maxTime < process.UtcTo - process.UtcFrom)
{
maxTime = (TimeSpan)(process.UtcTo - process.UtcFrom);
}
}
//if mor than one id -> add avg graph and stuff
if (processids.Length > 1)
{
if (viewOptions.Contains(SwhkViewOptions.AverageGraph))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = -1,
PrecictiveProcessData = DataContainers,
Name = "Average Graph Normalized",
Seq = 6,
ChartDataSourceId = 1,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//Sollhüllwert based on AVG Graph
if (viewOptions.Contains(SwhkViewOptions.AvgEnvelope))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = -2,
PrecictiveProcessData = DataContainers,
Name = "Average Swhk",
Seq = 7,
ChartDataSourceId = 1,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//lower bound of avg
if (viewOptions.Contains(SwhkViewOptions.LowerAverage))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = -3,
PrecictiveProcessData = DataContainers,
Name = "Average Graph Lower",
Seq = 8,
ChartDataSourceId = 1,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
//upper bound of avg
if (viewOptions.Contains(SwhkViewOptions.UpperAverage))
{
area.Functions.Add(new PredictiveChartFunction()
{
ChartFunctionId = -4,
PrecictiveProcessData = DataContainers,
Name = "Average Graph Upper",
Seq = 9,
ChartDataSourceId = 1,
FillColor = "#" + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2") + ((byte)rand.Next(256)).ToString("X2")
});
}
}
cbpar.Stop = cbpar.Start + maxTime;
par.Blocks.Add(cbpar);
//ViewModel
var viewModel = new ChartViewModel();
viewModel.Load(chartConfig);
viewModel.Timelines.AddRange(par.Blocks.Select(b => b.ToTimelineViewModel()));
viewModel.PredictiveFunctions.AddRange(DataContainers);
if (viewModel.Timelines.Count != 0)
{
SaveDisplayInterval(viewModel.Timelines[0].Start, viewModel.Timelines[0].Stop);
}
return(View(viewModel));
}
public HomeController(IProductsService productsService)
{
_productsService = productsService;
_chartConfig = new ChartConfig();
}
public ChartConfigForm(ChartConfig config)
{
InitializeComponent();
_chartConfigData = config;
}
public GraphData(TimeSpan startTime, string title,
ChartConfig chartConfig)
{
_startTime = startTime;
this.Title = title;
_clipMax = chartConfig.ClipMax;
LinearAcceleration = new LineSeries()
{
Title = "LinearAccelereation",
YAxisKey = "LinearAccelereation",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0xff, 0, 0),
};
AngularVelocity = new LineSeries()
{
Title = "AngularVelocity",
YAxisKey = "AngularVelocity",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0, 0xff, 0),
};
Angle = new LineSeries()
{
Title = "Angle",
YAxisKey = "Angle",
LineStyle = LineStyle.Solid,
Color = OxyColor.FromRgb(0, 0, 0xff),
};
Axes.Add(new LinearAxis
{
Key = "LinearAccelereation",
Position = AxisPosition.Left,
Minimum = chartConfig.LinearAccelerationMin,
Maximum = chartConfig.LinearAccelerationMax,
});
Axes.Add(new LinearAxis
{
Key = "AngularVelocity",
Position = AxisPosition.Left,
Minimum = chartConfig.AngularVelocityMin,
Maximum = chartConfig.AngularVelocityMax,
});
Axes.Add(new LinearAxis
{
Key = "Angle",
Position = AxisPosition.Left,
Minimum = chartConfig.AngleMin,
Maximum = chartConfig.AngleMax,
});
//Axes.Add(new LinearAxis
//{
// Position = AxisPosition.Left,
// Minimum = Math.Min(Math.Min(chartConfig.LinearAccelerationMin, chartConfig.AngularVelocityMin), chartConfig.AngleMin),
// Maximum = Math.Max(Math.Max(chartConfig.LinearAccelerationMax, chartConfig.AngularVelocityMax), chartConfig.AngleMax),
//});
this.IsLegendVisible = true;
this.Series.Add(LinearAcceleration);
this.Series.Add(AngularVelocity);
this.Series.Add(Angle);
//this.Series.Add(new FunctionSeries(Math.Cos, 0, 10, 0.1, "cos(x)"));
}
