private void Rearrange(int pointsCount)
{
CtlPresenter.Clear();
if (pointsCount != Const.CurrentValue)
{
PointsCount = pointsCount;
}
if (Data == null || Data.Length != PointsCount)
{
Data = new double[PointsCount];
Stat = new double[PointsCount];
}
double maxStat = Stat == null ? 0 : Stat.Max();
for (int p = 0; p < PointsCount; ++p)
{
var pos = GetPointPosition(p);
if (Data[p] > Threshold)
{
DrawPoint(pos.Item1, pos.Item2, Data[p], true);
}
else
{
DrawPoint(pos.Item1, pos.Item2, maxStat > 0 ? Stat[p] / maxStat : 0, false);
}
}
CtlPresenter.Update();
}
private void Rearrange(int pointsCount)
{
if (pointsCount == Const.CurrentValue)
{
pointsCount = PointsCount;
}
else
{
PointsCount = pointsCount;
}
var width = Math.Max(Width, PointsRearrangeSnap * PointSize);
int snaps = width / (PointsRearrangeSnap * PointSize);
CtlPresenter.Height = 1 + PointSize * (int)Math.Ceiling(1 + (double)(PointsCount / (snaps * PointsRearrangeSnap)));
CtlPresenter.StartRender();
Range.For(PointsCount, p =>
{
var pos = GetPointPosition(p);
DrawPoint(pos.Item1, pos.Item2, 0);
});
if (Data != null)
{
Range.For(Data.Length, y => TogglePoint(y, Data[y] > Threshold ? Data[y] : 0));
}
CtlPresenter.CtlBox.Invalidate();
}
private void DrawLabel(DynamicStatistics.PlotPoints data, Color color)
{
var text = new FormattedText(TimeSpan.FromTicks(data.Last().Item2 - data[0].Item2).ToString(@"hh\:mm\:ss") + " / " + Converter.DoubleToText(data.Last().Item1, "N6", false) + " %", Culture.Current, FlowDirection.LeftToRight, Font, 10, Tools.Draw.GetBrush(color), Render.PixelsPerDip);
CtlPresenter.DrawRectangle(Tools.Draw.GetBrush(Tools.Draw.GetColor(150, Colors.White)), null, Rects.Get((ActualWidth - AxisOffset - text.Width) / 2 - 5, ActualHeight - AxisOffset - 20, text.Width + 10, text.Height));
CtlPresenter.DrawText(text, Points.Get((ActualWidth - AxisOffset - text.Width) / 2, ActualHeight - AxisOffset - 20));
}
public void Draw(Dictionary<string, string> stat)
{
CtlPresenter.Clear();
if (stat == null)
{
return;
}
string text = string.Empty;
foreach (var pair in stat)
{
if (pair.Key.Length == 0)
{
text += "\r\n";
}
else
{
text += pair.Key + ": " + pair.Value + "\r\n";
}
}
var formattedText = new FormattedText(text, Culture.Current, FlowDirection.LeftToRight, Font, 10, Brushes.Black, Render.PixelsPerDip);
CtlPresenter.DrawText(formattedText, Points.Get(10, 0));
Width = Math.Max(ActualWidth, formattedText.WidthIncludingTrailingWhitespace + 10);
CtlPresenter.Update();
}
private void Draw(bool fullState, NetworkDataModel model, bool isOnlyWeights, bool isOnlyChangedWeights, bool isHighlightChangedWeights)
{
if (model == null)
{
CtlPresenter.Clear();
return;
}
CtlPresenter.Clear();
//lock (Main.ApplyChangesLocker)
{
if (model.Layers.Count > 0)
{
foreach (var layer in model.Layers)
{
if (layer == model.Layers.Last())
{
break;
}
DrawLayersLinks(fullState, model, layer, layer.Next, isOnlyWeights, isOnlyChangedWeights, isHighlightChangedWeights);
}
foreach (var layer in model.Layers)
{
DrawLayerNeurons(fullState, model, layer);
}
}
}
CtlPresenter.Update();
}
private void DrawPoint(int x, int y, double value, bool isData)
{
var brush = value == 0 ? Brushes.White : (isData ? Draw.GetBrush(value) : Draw.GetBrush(Draw.GetColor((byte)(255 * value), Colors.Green)));
var pen = Draw.GetPen(Colors.Black);
CtlPresenter.DrawRectangle(brush, pen, Rects.Get(x * PointSize, y * PointSize, PointSize, PointSize));
}
private void Render2()
{
int left = 3 + (CtlPresenter.Width / 2) - ((Model.Layers.Count - 1) * 125) / 2;
int top = (CtlPresenter.Height / 2) - Model.Layers[0].Height / 2 - 30;
int distance = 50;
int alpha = 100;
int mult = Height / 12;
var zeroColor = new Pen(Color.FromArgb(alpha, Color.Gray));
for (int layer = 0; layer < Model.Layers.Count - 1; ++layer)
{
var neuronsCount = Model.Layers[layer].Neurons.Count;
for (int neuron = 0; neuron < neuronsCount; ++neuron)
{
CtlPresenter.G.DrawLine(zeroColor, left - neuron + layer * 150, top + neuron, 100 + left - neuron + layer * 150, top + neuron);
for (int weight = 0; weight < Model.Layers[layer].Neurons[neuron].Weights.Count; ++weight)
{
var value = Model.Layers[layer].Neurons[neuron].Weights[weight].Weight;
var hover = value == 0 ? 0 : 30 * Math.Sign(value);
using (var pen = Draw.GetPen(value, 0, alpha))
{
CtlPresenter.G.DrawLine(pen,
left - neuron + layer * 150 + weight,
top + neuron - hover,
left - neuron + layer * 150 + weight,
top + neuron - hover - (float)(mult * value));
CtlPresenter.G.FillEllipse(Brushes.Orange,
left - neuron + layer * 150 + weight - 1,
top + neuron - hover - (float)(mult * value),
2,
2);
}
}
}
CtlPresenter.G.DrawLine(Pens.Black,
left - 105,
top + 100 - 30,
left - 105,
top + 100 - 30 - mult);
CtlPresenter.G.DrawString("1", Font, Brushes.Black,
left - 115,
top + 100 - Font.Height - 30);
CtlPresenter.Invalidate();
}
zeroColor.Dispose();
}
public RandomViewer(string randomizer, double?a)
{
InitializeComponent();
Text = "Randomizer Viewer | " + randomizer;
Randomizer = randomizer;
A = a;
RandomizeMode.Helper.Invoke(Randomizer, Model, A);
CtlPresenter.Width = Screen.PrimaryScreen.Bounds.Width;
CtlPresenter.Height = Screen.PrimaryScreen.Bounds.Height;
CtlPresenter.Left = Width / 2 - CtlPresenter.Width / 2;
CtlPresenter.Top = Height / 2 - CtlPresenter.Height / 2;
CtlPresenter.StartRender();
}
private void DrawLayerNeurons(bool fullState, NetworkDataModel model, LayerDataModel layer)
{
double threshold = model.Layers[0] == layer ? model.InputThreshold : 0;
var biasColor = Tools.Draw.GetPen(Colors.Orange);
NeuronDataModel prevNeuron = null;
foreach (var neuron in layer.Neurons)
{
if (fullState || neuron.IsBias || neuron.Activation > threshold || layer.Id > 0)
{
if (!Coordinator.ContainsKey(neuron))
{
Coordinator.Add(neuron, Points.Get(LayerX(model, layer), TOP_OFFSET + VerticalShift(model, layer) + neuron.Id * VerticalDistance(layer.Height)));
}
// Skip intersected neurons on first layer to improove performance.
if (!fullState && !neuron.IsBias && model.Layers[0] == layer && prevNeuron != null)
{
if (Coordinator[neuron].Y - Coordinator[prevNeuron].Y < NEURON_SIZE)
{
continue;
}
}
prevNeuron = neuron;
var pen = Tools.Draw.GetPen(neuron.Activation);
var brush = pen.Brush;
if (neuron.IsBias)
{
CtlPresenter.DrawEllipse(Brushes.Orange, biasColor, Coordinator[neuron], BIAS_RADIUS, BIAS_RADIUS);
}
CtlPresenter.DrawEllipse(brush, pen, Coordinator[neuron], NEURON_RADIUS, NEURON_RADIUS);
}
}
}
private void DrawData(DynamicStatistics.PlotPoints data, Color color, PointFunc func, bool isRect)
{
if (data == null || data.FirstOrDefault() == null)
{
return;
}
var pen = Tools.Draw.GetPen(color);
var firstData = data[0];
var lastData = data.Last();
var ticks = lastData.Item2 - firstData.Item2;
Point prevPoint = new Point(-1000, -1000);
var prevData = firstData;
foreach (var d in data)
{
var point = func(data, d, ticks);
if ((point.X - prevPoint.X) > 10 || Math.Abs(point.Y - prevPoint.Y) > 10 || d == lastData) // opt
{
CtlPresenter.DrawLine(pen, func(data, prevData, ticks), point);
if (isRect)
{
CtlPresenter.DrawRectangle(pen.Brush, pen, Rects.Get(point.X - 6 / 2, point.Y - 6 / 2, 6, 6));
}
else
{
CtlPresenter.DrawEllipse(pen.Brush, pen, Points.Get(point.X, point.Y), 7 / 2, 7 / 2);
}
prevData = d;
prevPoint = point;
}
}
}
public void Draw(ListX <NetworkDataModel> models, NetworkDataModel selectedModel)
{
if (IsBaseRedrawNeeded)
{
DrawPlotter();
IsBaseRedrawNeeded = false;
}
CtlPresenter.Clear();
if (models == null)
{
return;
}
var model = models[0];
while (model != null)
{
if (!model.IsEnabled)
{
continue;
}
DrawData(model.DynamicStatistics.CopyForRender.PercentData, Tools.Draw.GetColor(220, model.Color), GetPointPercentData, false);
DrawData(model.DynamicStatistics.CopyForRender.CostData, Tools.Draw.GetColor(150, model.Color), GetPointCostData, true);
model = model.Next;
}
if (selectedModel != null && selectedModel.DynamicStatistics.PercentData.Count > 0)
{
DrawLabel(selectedModel.DynamicStatistics.PercentData, selectedModel.Color);
}
CtlPresenter.Update();
}
private void Render()
{
int left = 3 + (CtlPresenter.Width / 2) - ((Model.Layers.Count - 1) * 125) / 2;
int top = (CtlPresenter.Height / 2) - Model.Layers[0].Height / 2 - 30;
int distance = 50;
int alpha = 200;
int mult = Height / 12;
int unit = 30;
var zeroColor = new Pen(Color.FromArgb(100, Color.Gray));
var rangeColor = new Pen(Color.FromArgb(50, Color.White));
// get ranges
var ranges = new Dictionary <int, HashSet <int> >();
for (int layer = 0; layer < Model.Layers.Count - 1; ++layer)
{
ranges[layer] = new HashSet <int>();
var neuronsCount = Model.Layers[layer].Neurons.Count;
for (int neuron = 0; neuron < neuronsCount; ++neuron)
{
CtlPresenter.G.DrawLine(zeroColor, left - neuron + layer * 150, top + neuron, 100 + left - neuron + layer * 150, top + neuron);
bool hasNextRange = false;
for (int weight = 0; weight < Model.Layers[layer].Neurons[neuron].Weights.Count; ++weight)
{
var value = Model.Layers[layer].Neurons[neuron].Weights[weight].Weight;
if (value > 0)
{
ranges[layer].Add(1);
}
if (value > 1)
{
ranges[layer].Add(2);
}
if (value > 2)
{
ranges[layer].Add(3);
}
if (value > 3)
{
ranges[layer].Add(4);
}
if (value > 4)
{
ranges[layer].Add(5);
}
if (value > 5)
{
ranges[layer].Add(6);
}
if (value > 6)
{
ranges[layer].Add(7);
}
}
}
}
for (int layer = 0; layer < Model.Layers.Count - 1; ++layer)
{
var neuronsCount = Model.Layers[layer].Neurons.Count;
for (int neuron = 0; neuron < neuronsCount; ++neuron)
{
CtlPresenter.G.DrawLine(zeroColor, left - neuron + layer * 150, top + neuron, 100 + left - neuron + layer * 150, top + neuron);
for (int r = 0; r < ranges[layer].Count; ++r)
{
for (int weight = 0; weight < Model.Layers[layer].Neurons[neuron].Weights.Count; ++weight)
{
var value = Model.Layers[layer].Neurons[neuron].Weights[weight].Weight;
var origValue = value;
if (value > 0)
{
if (value > r + 1)
{
value = 1;
}
else
{
value -= r;
}
}
var hover = value == 0 ? 0 : unit *Math.Sign(value);
using (var pen = new Pen(Draw.GetColorDradient(Color.Black, origValue >= 0 ? Color.Red : Color.Blue, 200, Math.Abs(origValue) / ranges[layer].Max())))// .GetPen(origValue, 1, alpha))
{
if (value > 0 && r > 0)
{
CtlPresenter.G.FillEllipse(Brushes.White,
left - neuron + layer * 150 + weight - 1,
top + neuron - hover - mult * r - 1,
3,
3);
}
if (value >= 0 || r == 0)
{
CtlPresenter.G.DrawLine(pen,
left - neuron + layer * 150 + weight,
top + neuron - hover - mult * r,
left - neuron + layer * 150 + weight,
top + neuron - hover - (float)(mult * (r + 1) * value));
}
if ((value < 0 && r == 0) || (value >= 0 && value < 1))
{
CtlPresenter.G.FillEllipse(Brushes.Orange,
left - neuron + layer * 150 + weight - 1,
top + neuron - hover - (float)(mult * (r + 1) * value),
2,
2);
}
}
}
if (r < ranges[layer].Count - 1)
{
CtlPresenter.G.DrawLine(rangeColor, left - neuron + layer * 150, top + neuron - unit - mult * (r + 1), 100 + left - neuron + layer * 150, top + neuron - unit - mult * (r + 1));
}
}
}
CtlPresenter.G.DrawLine(Pens.Black,
left - 105,
top + 100 - unit,
left - 105,
top + 100 - unit - mult);
CtlPresenter.G.DrawString("1", Font, Brushes.Black,
left - 115,
top + 100 - Font.Height - unit);
CtlPresenter.Invalidate();
}
zeroColor.Dispose();
rangeColor.Dispose();
}
private void DrawLayersLinks(bool fullState, NetworkDataModel model, LayerDataModel layer1, LayerDataModel layer2, bool isOnlyWeights, bool isOnlyChangedWeights, bool isHighlightChangedWeights)
{
double threshold = model.Layers[0] == layer1 ? model.InputThreshold : 0;
NeuronDataModel prevNeuron = null;
foreach (var neuron1 in layer1.Neurons)
{
if (!Coordinator.ContainsKey(neuron1))
{
Coordinator.Add(neuron1, Points.Get(LayerX(model, layer1), TOP_OFFSET + VerticalShift(model, layer1) + neuron1.Id * VerticalDistance(layer1.Height)));
}
// Skip intersected neurons on first layer to improove performance.
if (!fullState && !neuron1.IsBias && model.Layers[0] == layer1 && prevNeuron != null)
{
if (Coordinator[neuron1].Y - Coordinator[prevNeuron].Y < NEURON_SIZE)
{
continue;
}
}
if (fullState || neuron1.IsBias || neuron1.Activation > threshold)
{
foreach (var neuron2 in layer2.Neurons)
{
if (!neuron2.IsBias || (neuron2.IsBiasConnected && neuron1.IsBias))
{
if (fullState || ((neuron1.IsBias || neuron1.Activation > threshold) && neuron1.AxW(neuron2) != 0))
{
Pen pen = null;
Pen penChange = null;
bool isWeightChanged = false;
var weight = neuron1.WeightTo(neuron2);
if (WeightsData.TryGetValue(weight, out double prevWeight))
{
if (prevWeight != weight.Weight)
{
isWeightChanged = true;
WeightsData[weight] = weight.Weight;
}
}
else
{
prevWeight = 0;
isWeightChanged = true;
WeightsData.Add(weight, weight.Weight);
}
double fraction = Math.Min(1, Math.Abs((prevWeight - weight.Weight) / prevWeight));
if (fraction <= 0.001)
{
isWeightChanged = false;
}
if (isWeightChanged && isHighlightChangedWeights)
{
penChange = Tools.Draw.GetPen(Colors.Lime);
}
if (isOnlyWeights)
{
if ((isWeightChanged && isOnlyChangedWeights) || !isOnlyChangedWeights)
{
pen = Tools.Draw.GetPen(weight.Weight, 1);
}
}
else
{
pen = Tools.Draw.GetPen(neuron1.AxW(neuron2), 1);
}
if (!isOnlyChangedWeights && isHighlightChangedWeights && isWeightChanged)
{
pen = penChange;
penChange = null;
}
if (pen != null)
{
if (!Coordinator.ContainsKey(neuron2))
{
Coordinator.Add(neuron2, Points.Get(LayerX(model, layer2), TOP_OFFSET + VerticalShift(model, layer2) + neuron2.Id * VerticalDistance(layer2.Height)));
}
CtlPresenter.DrawLine(pen, Coordinator[neuron1], Coordinator[neuron2]);
prevNeuron = neuron1;
}
if (penChange != null)
{
CtlPresenter.DrawLine(penChange, Coordinator[neuron1], Coordinator[neuron2]);
prevNeuron = neuron1;
}
}
}
}
}
}
}
public void Render(long startTicks, long endTicks, DataManager manager, bool isOdd, bool isHeadOfGroup)
{
CtlPresenter.Clear();
using (var dc = CtlPresenter.G())
{
var width = CtlPresenter.ActualWidth;
var height = CtlPresenter.ActualHeight;
if (Values.Count == 0)
{
//todo: add grid
return;
}
CtlGroup.Visibility = isHeadOfGroup ? Visibility.Visible : Visibility.Collapsed;
double rangeMin = RangeMinimum;
double rangeMax = RangeMaximum;
/* auto range
* if (manager.IsAutoRangeMinMax)
* {
* var min = Values.Min(v => v.CtlValue.Value);
* var max = Values.Max(v => v.CtlValue.Value);
*
* rangeMax = max + min;
* rangeMin = 0;
* }
*/
// Min-Max range
if (manager.IsAutoRangeMinMax)
{
var min = Values.Min(v => v.CtlValue.Value);
var max = Values.Max(v => v.CtlValue.Value);
rangeMax = max;
rangeMin = min;
}
if (rangeMin == rangeMax)
{
var pen = GetPenFromValue(rangeMin);
CtlMinRange.Text = Converter.DoubleToText(rangeMin, "F3", true);
CtlMinRange.VerticalAlignment = VerticalAlignment.Center;
CtlMinRange.Background = pen.Brush;
CtlMaxRange.Visibility = Visibility.Collapsed;
}
else
{
var penMin = GetPenFromValue(rangeMin);
var penMax = GetPenFromValue(rangeMax);
CtlMinRange.Text = Converter.DoubleToText(rangeMin, "F3", true);
CtlMinRange.Background = penMin.Brush;
CtlMaxRange.Text = Converter.DoubleToText(rangeMax, "F3", true);
CtlMaxRange.Background = penMax.Brush;
}
double optimalValue = CriticalMinumim + (CriticalMaximum - CriticalMinumim) / 2;
if (manager.IsShowOptimalLine && CriticalMinumim > 0)
{
if (rangeMax < optimalValue)
{
rangeMax = optimalValue;
}
if (rangeMin > optimalValue)
{
rangeMin = optimalValue;
}
}
var prevValue = Values[0];
double val = prevValue.CtlValue.Value;
var prevPen = GetPenFromValue(val);
double prevX = GetX(startTicks, endTicks, prevValue.CtlDate.SelectedDate.Value);
foreach (var value in Values)
{
if (prevValue != null)
{
var v = value.CtlValue.Value;
var currPen = GetPenFromValue(v);
if (currPen != prevPen)
{
var end = value == Values[Values.Count - 1] ? value.CtlDate.SelectedDate.Value : value.CtlDate.SelectedDate.Value.AddDays(-1);
var dayOfChange = GetDayOfChange2(prevValue, value, end, prevPen);
val = GetValueForDate(prevValue, value, dayOfChange.Ticks);
var pen = GetPenFromValue(val);
bool lastDay = value == Values[Values.Count - 1] && dayOfChange == end;
if (pen != prevPen || lastDay)
{
double x = (lastDay && pen == prevPen) ? width : GetX(startTicks, endTicks, dayOfChange);
CtlPresenter.DrawRectangle(prevPen.Brush, prevPen, Rects.Get(prevX, 0, x - prevX, height), dc);
prevX = x;
prevPen = pen;
}
}
}
prevValue = value;
}
CtlPresenter.DrawRectangle(prevPen.Brush, prevPen, Rects.Get(prevX, 0, width - prevX, height), dc);
// grid
var endDate = new DateTime(endTicks);
var startDate = new DateTime(startTicks);
for (DateTime day = startDate; day <= endDate; day = day.AddMonths(1))
{
double x = GetX(startTicks, endTicks, day);
CtlPresenter.DrawLine(day.Month == 1 ? penGridYear : (isOdd ? penGrid : penGridAlt), Points.Get(x, 0), Points.Get(x, height), dc);
}
double xt = GetX(startTicks, endTicks, DateTime.Today);
CtlPresenter.DrawLine(penToday, Points.Get(xt, 0), Points.Get(xt, height), dc);
// optimal line
if (manager.IsShowOptimalLine && CriticalMinumim > 0)
{
double y = GetY(optimalValue, rangeMin, rangeMax);
CtlPresenter.DrawLine(penOptimalValue, Points.Get(0, y), Points.Get(width, y), dc);
}
// graph
prevValue = null;
foreach (var value in Values)
{
var point = GetValuePoint(value, startTicks, endTicks, rangeMin, rangeMax);
if (prevValue != null)
{
var prevPoint = GetValuePoint(prevValue, startTicks, endTicks, rangeMin, rangeMax);
CtlPresenter.DrawLine(penLine, prevPoint, point, dc);
}
// Critical border circle
var pointPen = penLine;
double pointRadius = 5 * Tools.Render.PixelSize;
if (CriticalMinumim != CriticalMaximum)
{
if (CriticalMinumim > RangeMinimum && value.CtlValue.Value == CriticalMinumim)
{
CtlPresenter.DrawEllipse(penCriticalBorder.Brush, penCriticalBorder, point, pointRadius, pointRadius, dc);
pointPen = penLow;
}
else if (CriticalMaximum < RangeMaximum && value.CtlValue.Value == CriticalMaximum)
{
CtlPresenter.DrawEllipse(penCriticalBorder.Brush, penCriticalBorder, point, pointRadius, pointRadius, dc);
pointPen = penHigh;
}
}
// Value point
CtlPresenter.DrawEllipse(pointPen.Brush, pointPen, point, pointRadius / 2, pointRadius / 2, dc);
prevValue = value;
}
//
// values
var brush = Tools.Draw.GetBrush(Colors.White);
var prevRects = new List <Rect>();
for (int i = Values.Count - 1; i >= 0; --i)
{
var value = Values[i];
var point = GetValuePoint(value, startTicks, endTicks, rangeMin, rangeMax);
var fmt = new FormattedText(Converter.DoubleToText(value.CtlValue.Value, "F3"), Culture.Current, FlowDirection.LeftToRight, Font, 9, Brushes.Black, Tools.Render.PixelsPerDip);
var x = point.X + Tools.Render.PixelSize;
var y = point.Y >= height / 2 ? point.Y - Tools.Render.PixelSize - fmt.Height : point.Y + Tools.Render.PixelSize;
var rect = Rects.Get(x, y, fmt.Width + 2 * Tools.Render.PixelSize, fmt.Height - 2 * Tools.Render.PixelSize);
if (!prevRects.Any(prevRect => Rects.Intersects(rect, prevRect)))
{
CtlPresenter.DrawRectangle(brush, null, rect, dc);
CtlPresenter.DrawText(fmt, Points.Get(x + Tools.Render.PixelSize, y - Tools.Render.PixelSize), 0, dc);
prevRects.Add(rect);
}
}
}
IsRenderNeeded = false;
}
private void RandomizerViewer_SizeChanged(object sender, SizeChangedEventArgs e)
{
CtlPresenter.SetValue(System.Windows.Controls.Canvas.LeftProperty, (CtlCanvas.ActualWidth - CtlPresenter.ActualWidth) / 2);
CtlPresenter.SetValue(System.Windows.Controls.Canvas.TopProperty, (CtlCanvas.ActualHeight - CtlPresenter.ActualHeight) / 2);
}
public void Clear()
{
CtlPresenter.Clear();
}
public void Draw(ErrorMatrix matrix)
{
if (!IsLoaded)
{
return;
}
if (IsClassesChanged(matrix.Classes))
{
InitClassesFmtText(matrix.Classes);
DrawBase(matrix);
}
Classes = matrix.Classes;
CtlPresenter.Clear();
int size = 9;
long goodMax = 1;
long badMax = 1;
long axisOffset = 12;
long bound = 30;
for (int y = 0; y < matrix.Output.Length; ++y)
{
for (int x = 0; x < matrix.Input.Length; ++x)
{
if (x == y)
{
goodMax = Math.Max(goodMax, matrix.Matrix[x, y]);
}
else
{
badMax = Math.Max(badMax, matrix.Matrix[x, y]);
}
}
}
for (int y = 0; y < matrix.Output.Length; ++y)
{
for (int x = 0; x < matrix.Input.Length; ++x)
{
if (matrix.Matrix[y, x] > 0)
{
var value = (double)matrix.Matrix[y, x] / (double)(x == y ? goodMax : badMax);
var color = Tools.Draw.GetColorDradient(Colors.LightGray, x == y ? Colors.Green : Colors.Red, 255, value);
var brush = Tools.Draw.GetBrush(color);
CtlPresenter.DrawRectangle(brush, PenSilver, Rects.Get(axisOffset + x * size, axisOffset + y * size, size, size));
}
}
}
long outputMax = Math.Max(matrix.Output.Max(), 1);
for (int x = 0; x < matrix.Output.Length; ++x)
{
var color = Tools.Draw.GetColorDradient(Colors.White, matrix.Output[x] > matrix.Input[x] ? Colors.Red : matrix.Output[x] < matrix.Input[x] ? Colors.Blue : Colors.Green, 100, (double)matrix.Output[x] / (double)outputMax);
var brush = Tools.Draw.GetBrush(color);
CtlPresenter.DrawRectangle(brush, PenSilver, Rects.Get(axisOffset + x * size, 10 + axisOffset + matrix.Input.Length * size, size, (int)(bound * (double)matrix.Output[x] / (double)outputMax)));
}
long inputMax = Math.Max(matrix.Input.Max(), 1);
for (int y = 0; y < matrix.Input.Length; ++y)
{
var color = Tools.Draw.GetColorDradient(Colors.White, Colors.Green, 100, (double)matrix.Input[y] / (double)inputMax);
var brush = Tools.Draw.GetBrush(color);
CtlPresenter.DrawRectangle(brush, PenSilver, Rects.Get(11 + axisOffset + matrix.Output.Length * size, axisOffset + y * size, (int)(bound * (double)matrix.Input[y] / (double)inputMax), size));
}
CtlPresenter.Update();
}
public void Render(DateTime start, DateTime end)
{
CtlPresenter.Clear();
byte alpha = 100;
var winterColor = Draw.GetBrush(Draw.GetColor(alpha, Colors.White));
var springColor = Draw.GetBrush(Draw.GetColor(alpha, Colors.Blue));
var summerColor = Draw.GetBrush(Draw.GetColor(alpha, Colors.Green));
var autumColor = Draw.GetBrush(Draw.GetColor(alpha, Colors.Yellow));
var year0Color = Draw.GetBrush(Draw.GetColor(255, Colors.WhiteSmoke));
var year1Color = Draw.GetBrush(Draw.GetColor(255, Colors.DarkGray));
var dictMonth = new Dictionary <int, Brush>()
{
{ 1, winterColor },
{ 2, winterColor },
{ 3, springColor },
{ 4, springColor },
{ 5, springColor },
{ 6, summerColor },
{ 7, summerColor },
{ 8, summerColor },
{ 9, autumColor },
{ 10, autumColor },
{ 11, autumColor },
{ 12, winterColor }
};
var dictYear = new Dictionary <int, Brush>()
{
{ 0, year0Color },
{ 1, year1Color }
};
var width = CtlPresenter.ActualWidth;
var height = CtlPresenter.ActualHeight;
const double yearHeight = 5;
// grid
for (DateTime day = start; day <= end; day = day.AddMonths(1))
{
double x = GetX(start.Ticks, end.Ticks, day.Ticks);
double x2 = GetX(start.Ticks, end.Ticks, day.AddMonths(1).Ticks);
CtlPresenter.DrawRectangle(dictMonth[day.Month], penGrid, Rects.Get(x, 0, x2 - x, height - yearHeight));
if (day.Month == 1)
{
CtlPresenter.DrawLine(penGridYear, Points.Get(x, 0), Points.Get(x, height - yearHeight));
}
var fmt = new FormattedText(day.Date.ToString("MMM") + "\r\n" + (day.Date.Year - 2000), Culture.Current, FlowDirection.LeftToRight, Font, 9, Brushes.Black, Tools.Render.PixelsPerDip);
CtlPresenter.DrawText(fmt, Points.Get(x + (x2 - x - fmt.Width) / 2, (height - fmt.Height) / 2 - 3));
CtlPresenter.DrawRectangle(dictYear[day.Year % 2], null, Rects.Get(x, height - yearHeight, x2 - x, yearHeight));
}
CtlPresenter.DrawLine(penGrid, Points.Get(0, 0), Points.Get(width, 0));
//
}
