private void TransitionTimerTick(object sender, EventArgs e)
{
_transitionCounter += _transitionTimer.Interval;
if (_transitionCounter >= Interval)
{
_transitionCounter = 0;
_transitionState++;
if (_transitionState == 2)
{
_xAxis.Generate(_transitionCanvas);
_yAxis.GenerateAxis(_transitionCanvas.ScaleData.MaxData);
}
if (_transitionState == 3)
{
//reset timer info
_transitionTimer.Stop();
//switch canvas data
_canvasData = _transitionCanvas;
_scaleData = _canvasData.ScaleData;
_transitionCanvas = null;
////swap buffers in graphs
CanvasCollection.SwapBuffers();
////reset alpha blend
CanvasCollection.AlphaBlend(1f);
_transitionState = 0;
ShowUI();
}
}
}
/// <summary>
/// Draws the backbuffers of all graphs in the collection, in draw order
/// </summary>
/// <param name="scaleData">the scale data used to draw the graphs</param>
public void DrawCollectionBackBuffer(GraphScaleData scaleData)
{
foreach (var graph in List)
{
graph.DrawBackBuffer(scaleData);
}
}
public void SetCanvasData(CanvasData canvasData)
{
Border.BindData(new[] { new Vector2(-1, -1), new Vector2(1, -1), new Vector2(1, 1), new Vector2(-1, 1) });
DataVolume.BindData(canvasData.DataVolume);
PacketCount.BindData(canvasData.PacketCount);
for (var k = 0; k < MatchingCounts.Count; k++)
{
MatchingCounts[k].BindData(canvasData.MatchingCount[k]);
}
_canvasReady = true;
if (_canvasData != null)
{
_transitionCanvas = canvasData;
StartTransition();
}
else
{
_xAxis.Generate(canvasData);
_yAxis.GenerateAxis(canvasData.ScaleData.MaxData);
_scaleData = canvasData.ScaleData;
_canvasData = canvasData;
}
}
/// <summary>
/// Draws all graphs in the collection, in draw order
/// </summary>
/// <param name="scaleData">the scale data used to draw the graphs</param>
public void DrawCollection(GraphScaleData scaleData)
{
foreach (var graph in List)
{
graph.Draw(scaleData);
}
}
public void DrawBackBuffer(GraphScaleData scaleData)
{
if (Hide || _backData == null)
{
return;
}
float height = ScaleFunction.ScaledHeight(scaleData);
Matrix4 transform = Matrix4.CreateTranslation(scaleData.XShift, 0, 0) * Matrix4.Scale(2 / scaleData.BaseScale, 2 / height, 1) * Matrix4.CreateTranslation(-1, -1, 0);
GL.UniformMatrix4(_shaderProgram.UniformTransform, false, ref transform);
if (_drawMode == BeginMode.Lines || _drawMode == BeginMode.LineLoop || _drawMode == BeginMode.LineStrip)
{
GL.LineWidth(2f);
}
else if (_drawMode == BeginMode.Points)
{
GL.PointSize(2f);
}
if (_alphaBlend > 0)
{
Color4 col = Color;
col.A = 1 - _alphaBlend;
GL.Uniform4(_shaderProgram.UniformColor, col);
}
else
{
GL.Uniform4(_shaderProgram.UniformColor, Color);
}
if (_graphType == GraphType.SolidGraph)
{
_backBuffer.SetAttributeInfo(_shaderProgram.AttributeCoord2D, 2);
_backBuffer.BeginDraw();
_backBuffer.Draw(_drawMode);
_backBuffer.EndDraw();
_backBuffer.SetAttributeInfo(_shaderProgram.AttributeCoord2D, 2, false, 2 * Vector2.SizeInBytes);
GL.Uniform4(_shaderProgram.UniformColor, Color4.Black);
GL.LineWidth(1f);
_backBuffer.BeginDraw();
_backBuffer.Draw(BeginMode.LineStrip, _backData.Length / 2);
_backBuffer.EndDraw();
}
else
{
_backBuffer.BeginDraw();
_backBuffer.Draw(_drawMode, _backData.Length / 2);
_backBuffer.EndDraw();
}
}
/// <summary>
/// Creates a new CanvasData object, based on user specifications
/// </summary>
/// <param name="startTime">The time at wwhich the canvas view should start</param>
/// <param name="endTime">The time at wwhich the canvas view should end</param>
/// <param name="renderUnit">The basic rendering unit to use</param>
/// <param name="displayUnit">The display unit to use</param>
/// <param name="filterCount"></param>
public CanvasData(DateTime startTime, DateTime endTime, FrameNodeLevel renderUnit, FrameNodeLevel displayUnit)
{
DisplayUnit = displayUnit;
StartTime = startTime;
EndTime = endTime;
RenderUnit = renderUnit;
DataVolume = new GraphData();
PacketCount = new GraphData();
MatchingCount = new List <GraphData>();
for (int k = 0; k < CanvasManager.FileManager.TotalFilters; k++)
{
MatchingCount.Add(new GraphData());
}
ScaleData = new GraphScaleData(displayUnit, startTime, endTime, CanvasManager.FileManager.TotalFilters);
switch (displayUnit)
{
case FrameNodeLevel.Root:
Description = "Global View: " + startTime.ToString(CultureInfo.InvariantCulture) + " - " + endTime.ToString(CultureInfo.InvariantCulture);
break;
case FrameNodeLevel.Year:
Description = "Year View: " + startTime.Year;
break;
case FrameNodeLevel.Month:
Description = "Month View: " + MonthString(startTime.Month) + " " + startTime.Year;
break;
case FrameNodeLevel.Day:
Description = "Day View: " + DayString(startTime.Day) + " " + MonthString(startTime.Month) + " " + startTime.Year;
break;
case FrameNodeLevel.Hour:
Description = "Hour View: " + TimeString(startTime.Hour) + " - " + TimeString(endTime.Hour) + " " + DayString(startTime.Day) + " " + MonthString(startTime.Month) + " " + startTime.Year;
break;
case FrameNodeLevel.PartHour:
Description = "Part Hour View: " + TimeString(startTime.Hour, startTime.Minute) + " - " + TimeString(endTime.Hour, endTime.Minute) + " " + DayString(startTime.Day) + " " + MonthString(startTime.Month) + " " + startTime.Year;
break;
case FrameNodeLevel.Minute:
Description = "Minute View: " + TimeString(startTime.Hour, startTime.Minute) + " - " + TimeString(endTime.Hour, endTime.Minute) + " " + DayString(startTime.Day) + " " + MonthString(startTime.Month) + " " + startTime.Year;
break;
default:
throw new ArgumentOutOfRangeException("displayUnit");
}
}
/// <summary>
/// Creates a replica of the passed GraphScaleData
/// </summary>
/// <param name="data">the scale data to replicate</param>
public GraphScaleData(GraphScaleData data)
{
DisplayUnit = data.DisplayUnit;
XShift = data.XShift;
BaseScale = data.BaseScale;
TotalData = data.TotalData;
TotalPackets = data.TotalPackets;
VertexCount = data.VertexCount;
MinCount = data.MinCount;
MaxCount = data.MaxCount;
MinData = data.MinData;
MaxData = data.MaxData;
MinMatchingCount = new List <long>(data.MinMatchingCount);
MaxMatchingCount = new List <long>(data.MaxMatchingCount);
}
public float ScaledHeight(GraphScaleData scaleData)
{
switch (Function)
{
case GraphScaleFunction.Maximum:
switch (Target)
{
case GraphScaleTarget.DataVolume:
return(scaleData.MaxData);
case GraphScaleTarget.PacketCount:
return(scaleData.MaxCount);
case GraphScaleTarget.MatchingCount:
return(scaleData.MaxMatchingCount[FilterIndex]);
default:
throw new ArgumentOutOfRangeException();
}
case GraphScaleFunction.AverageOver2:
switch (Target)
{
case GraphScaleTarget.DataVolume:
return(scaleData.AvgDataVolume);
case GraphScaleTarget.PacketCount:
return(scaleData.AvgPacketCount);
case GraphScaleTarget.MatchingCount:
return(scaleData.AvgMatchingCount(FilterIndex));
default:
throw new ArgumentOutOfRangeException();
}
default:
throw new ArgumentOutOfRangeException();
}
}
public void DrawGraph()
{
if (!_canvasReady)
{
return;
}
CanvasManager.SimpleShader2D.UseProgram();
GL.MatrixMode(OpenTK.Graphics.OpenGL.MatrixMode.Modelview);
GL.Clear(ClearBufferMask.ColorBufferBit);
GL.Viewport((int)CanvasManager.CanvasLocationX, (int)CanvasManager.CanvasLocationY, (int)CanvasManager.CanvasWidth, (int)CanvasManager.CanvasHeight);
GL.Scissor((int)CanvasManager.CanvasLocationX, (int)CanvasManager.CanvasLocationY, (int)CanvasManager.CanvasWidth, (int)CanvasManager.CanvasHeight);
GL.Enable(EnableCap.ScissorTest);
var scale = new GraphScaleData(_scaleData);
if (_transitionState == 1) //reposition
{
float factor = _transitionCounter / Interval;
//x difference
scale.XShift = _scaleData.XShift + (_transitionCanvas.ScaleData.XShift - _scaleData.XShift) * factor;
//scale difference
scale.BaseScale = _scaleData.BaseScale + (_transitionCanvas.ScaleData.BaseScale - _scaleData.BaseScale) * factor;
}
else if (_transitionState == 2)
{
scale.XShift = _transitionCanvas.ScaleData.XShift;
scale.BaseScale = _transitionCanvas.ScaleData.BaseScale;
}
else
{
scale.XShift = _scaleData.XShift;
scale.BaseScale = _scaleData.BaseScale;
}
if (_transitionState == 2) //blend colors
{
//DataVolume.AlphaBlend = 1 - _transitionCounter / Interval;
//PacketCount.AlphaBlend = 1 - _transitionCounter / Interval;
CanvasCollection.AlphaBlend(1 - _transitionCounter / Interval);
}
_background.Draw(scale.XShift);
////draw data volume
//DataVolume.Draw(scale);
////draw packet count
//PacketCount.Draw(scale);
//
CanvasCollection.DrawCollection(scale);
if (_transitionState == 2)
{
//DataVolume.DrawBackBuffer(scale.BaseScale, _transitionCanvas.ScaleData.MaxData, scale.XShift);
//PacketCount.DrawBackBuffer(scale.BaseScale, _transitionCanvas.ScaleData.MaxCount, scale.XShift);
CanvasCollection.DrawCollectionBackBuffer(scale);
}
//////reset viewport
GL.Viewport(0, 0, CanvasManager.ControlWidth, CanvasManager.ControlHeight);
GL.Disable(EnableCap.ScissorTest);
Matrix4 transform = CanvasManager.ViewportTransform;
GL.UniformMatrix4(CanvasManager.SimpleShader2D.UniformTransform, false, ref transform);
GL.Uniform4(CanvasManager.SimpleShader2D.UniformColor, Color4.Black);
GL.LineWidth(2f);
Border.BeginDraw();
Border.Draw(BeginMode.LineLoop);
Border.EndDraw();
//transform.Invert();
//float left = -(transform.M11 - transform.M41);
//float right = transform.M11 + transform.M41;
_yAxis.Draw(_scaleData.MaxData);
_xAxis.Draw(scale.XShift, scale.BaseScale);
}
