コード例 #1
0
        public void Draw(IAffineTransformMatrix <T> Position, RendererBase <T> renderer)
        {
            T TextHeight = m_Position[1].Subtract(20);
            T Range      = (m_DataViewMaxY.Subtract(m_DataViewMinY));
            ConvTransform <T> TransformedLinesToDraw;
            ConvStroke <T>    StrockedTransformedLinesToDraw;

            RoundedRect <T>   BackGround            = new RoundedRect <T>(m_Position[0], m_Position[1].Subtract(1), m_Position[0].Add(m_Width), m_Position[1].Subtract(1).Add(m_Height).Add(2), M.New <T>(5));
            ConvTransform <T> TransformedBackGround = new ConvTransform <T>(BackGround, Position);

            renderer.Render(TransformedBackGround, new RGBA_Bytes(0, 0, 0, .5));

            // if the 0 line is within the window than draw it.
            if (m_DataViewMinY.LessThan(0) && m_DataViewMaxY.GreaterThan(0))
            {
                m_LinesToDraw.RemoveAll();
                m_LinesToDraw.MoveTo(m_Position[0],
                                     m_Position[1].Add(m_DataViewMinY.Negative().Multiply(M.New <T>(m_Height).Divide(Range))));


                m_LinesToDraw.LineTo(m_Position[0].Add((double)m_Width),
                                     m_Position[1].Add(m_DataViewMinY.Negative().Multiply(M.New <T>((double)m_Height).Divide(Range))));

                TransformedLinesToDraw         = new ConvTransform <T>(m_LinesToDraw, Position);
                StrockedTransformedLinesToDraw = new ConvStroke <T>(TransformedLinesToDraw);
                renderer.Render(StrockedTransformedLinesToDraw, new RGBA_Bytes(0, 0, 0, 1));
            }

            T MaxMax     = M.New <T>(-999999999);
            T MinMin     = M.New <T>(999999999);
            T MaxAverage = M.Zero <T>();

            foreach (KeyValuePair <String, HistoryData> historyKeyValue in m_DataHistoryArray)
            {
                HistoryData history = historyKeyValue.Value;
                m_LinesToDraw.RemoveAll();
                MaxMax     = M.Max(MaxMax, history.GetMaxValue());
                MinMin     = M.Min(MinMin, history.GetMinValue());
                MaxAverage = M.Max(MaxAverage, history.GetAverageValue());
                for (int i = 0; i < m_Width - 1; i++)
                {
                    if (i == 0)
                    {
                        m_LinesToDraw.MoveTo(m_Position[0].Add(i),
                                             m_Position[1].Add(history.GetItem(i).Subtract(m_DataViewMinY).Multiply(M.New <T>(m_Height).Divide(Range))));
                    }
                    else
                    {
                        m_LinesToDraw.LineTo(m_Position[0].Add(i),
                                             m_Position[1].Add(history.GetItem(i).Subtract(m_DataViewMinY).Multiply(M.New <T>((double)m_Height).Divide(Range))));
                    }
                }

                TransformedLinesToDraw         = new ConvTransform <T>(m_LinesToDraw, Position);
                StrockedTransformedLinesToDraw = new ConvStroke <T>(TransformedLinesToDraw);
                renderer.Render(StrockedTransformedLinesToDraw, history.m_Color);

                String Text = historyKeyValue.Key + ": Min:" + MinMin.ToString("0.0") + " Max:" + MaxMax.ToString("0.0");
                renderer.DrawString(Text, m_Position[0], TextHeight.Subtract(m_Height));
                TextHeight.SubtractEquals(20);
            }

            RoundedRect <T> BackGround2 = new RoundedRect <T>(
                m_Position[0],
                m_Position[1].Subtract(1),
                m_Position[0].Add((double)m_Width),
                m_Position[1].Subtract(1 + m_Height + 2), M.New <T>(5));

            ConvTransform <T> TransformedBackGround2        = new ConvTransform <T>(BackGround2, Position);
            ConvStroke <T>    StrockedTransformedBackGround = new ConvStroke <T>(TransformedBackGround2);

            renderer.Render(StrockedTransformedBackGround, new RGBA_Bytes(0.0, 0, 0, 1));

            //renderer.Color = BoxColor;
            //renderer.DrawRect(m_Position.x, m_Position.y - 1, m_Width, m_Height + 2);
        }
コード例 #2
0
        public void Draw(MatterHackers.Agg.Transform.ITransform Position, Graphics2D renderer)
        {
            double TextHeight = m_Position.y - 20;
            double Range      = (m_DataViewMaxY - m_DataViewMinY);
            VertexSourceApplyTransform TransformedLinesToDraw;
            Stroke StrockedTransformedLinesToDraw;

            RoundedRect BackGround = new RoundedRect(m_Position.x, m_Position.y - 1, m_Position.x + m_Width, m_Position.y - 1 + m_Height + 2, 5);
            VertexSourceApplyTransform TransformedBackGround = new VertexSourceApplyTransform(BackGround, Position);

            renderer.Render(TransformedBackGround, new RGBA_Bytes(0, 0, 0, .5));

            // if the 0 line is within the window than draw it.
            if (m_DataViewMinY < 0 && m_DataViewMaxY > 0)
            {
                m_LinesToDraw.remove_all();
                m_LinesToDraw.MoveTo(m_Position.x,
                                     m_Position.y + ((0 - m_DataViewMinY) * m_Height / Range));
                m_LinesToDraw.LineTo(m_Position.x + m_Width,
                                     m_Position.y + ((0 - m_DataViewMinY) * m_Height / Range));
                TransformedLinesToDraw         = new VertexSourceApplyTransform(m_LinesToDraw, Position);
                StrockedTransformedLinesToDraw = new Stroke(TransformedLinesToDraw);
                renderer.Render(StrockedTransformedLinesToDraw, new RGBA_Bytes(0, 0, 0, 1));
            }

            double MaxMax     = -999999999;
            double MinMin     = 999999999;
            double MaxAverage = 0;

            foreach (KeyValuePair <String, HistoryData> historyKeyValue in m_DataHistoryArray)
            {
                HistoryData history = historyKeyValue.Value;
                m_LinesToDraw.remove_all();
                MaxMax     = System.Math.Max(MaxMax, history.GetMaxValue());
                MinMin     = System.Math.Min(MinMin, history.GetMinValue());
                MaxAverage = System.Math.Max(MaxAverage, history.GetAverageValue());
                for (int i = 0; i < m_Width - 1; i++)
                {
                    if (i == 0)
                    {
                        m_LinesToDraw.MoveTo(m_Position.x + i,
                                             m_Position.y + ((history.GetItem(i) - m_DataViewMinY) * m_Height / Range));
                    }
                    else
                    {
                        m_LinesToDraw.LineTo(m_Position.x + i,
                                             m_Position.y + ((history.GetItem(i) - m_DataViewMinY) * m_Height / Range));
                    }
                }

                TransformedLinesToDraw         = new VertexSourceApplyTransform(m_LinesToDraw, Position);
                StrockedTransformedLinesToDraw = new Stroke(TransformedLinesToDraw);
                renderer.Render(StrockedTransformedLinesToDraw, history.m_Color);

                String Text = historyKeyValue.Key + ": Min:" + MinMin.ToString("0.0") + " Max:" + MaxMax.ToString("0.0");
                renderer.DrawString(Text, m_Position.x, TextHeight - m_Height);
                TextHeight -= 20;
            }

            RoundedRect BackGround2 = new RoundedRect(m_Position.x, m_Position.y - 1, m_Position.x + m_Width, m_Position.y - 1 + m_Height + 2, 5);
            VertexSourceApplyTransform TransformedBackGround2 = new VertexSourceApplyTransform(BackGround2, Position);
            Stroke StrockedTransformedBackGround = new Stroke(TransformedBackGround2);

            renderer.Render(StrockedTransformedBackGround, new RGBA_Bytes(0.0, 0, 0, 1));

            //renderer.Color = BoxColor;
            //renderer.DrawRect(m_Position.x, m_Position.y - 1, m_Width, m_Height + 2);
        }
コード例 #3
0
        public override void OnDraw(Graphics2D graphics2D)
        {
            double currentTextHeight = -20;
            double Range             = (valueMax - valueMin);
            VertexSourceApplyTransform TransformedLinesToDraw;
            Stroke StrockedTransformedLinesToDraw;

            Vector2     renderOffset = new Vector2(1, Height - graphHeight - 22);
            RoundedRect backGround   = new RoundedRect(renderOffset.x, renderOffset.y - 1, renderOffset.x + graphWidth, renderOffset.y - 1 + graphHeight + 2, 5);

            graphics2D.Render(backGround, new RGBA_Bytes(0, 0, 0, .5));

            // if the 0 line is within the window than draw it.
            if (valueMin < 0 && valueMax > 0)
            {
                linesToDrawStorage.remove_all();
                linesToDrawStorage.MoveTo(renderOffset.x,
                                          renderOffset.y + ((0 - valueMin) * graphHeight / Range));
                linesToDrawStorage.LineTo(renderOffset.x + graphWidth,
                                          renderOffset.y + ((0 - valueMin) * graphHeight / Range));
                StrockedTransformedLinesToDraw = new Stroke(linesToDrawStorage);
                graphics2D.Render(StrockedTransformedLinesToDraw, new RGBA_Bytes(0, 0, 0, 1));
            }

            double MaxMax     = -999999999;
            double MinMin     = 999999999;
            double MaxAverage = 0;

            foreach (KeyValuePair <String, HistoryData> historyKeyValue in dataHistoryArray)
            {
                HistoryData history = historyKeyValue.Value;
                linesToDrawStorage.remove_all();
                MaxMax     = System.Math.Max(MaxMax, history.GetMaxValue());
                MinMin     = System.Math.Min(MinMin, history.GetMinValue());
                MaxAverage = System.Math.Max(MaxAverage, history.GetAverageValue());
                for (int i = 0; i < graphWidth - 1; i++)
                {
                    if (i == 0)
                    {
                        linesToDrawStorage.MoveTo(renderOffset.x + i,
                                                  renderOffset.y + ((history.GetItem(i) - valueMin) * graphHeight / Range));
                    }
                    else
                    {
                        linesToDrawStorage.LineTo(renderOffset.x + i,
                                                  renderOffset.y + ((history.GetItem(i) - valueMin) * graphHeight / Range));
                    }
                }

                StrockedTransformedLinesToDraw = new Stroke(linesToDrawStorage);
                graphics2D.Render(StrockedTransformedLinesToDraw, history.lineColor);

                String Text = historyKeyValue.Key + ": Min:" + MinMin.ToString("0.0") + " Max:" + MaxMax.ToString("0.0") + " Avg:" + MaxAverage.ToString("0.0");
                graphics2D.DrawString(Text, renderOffset.x, renderOffset.y + currentTextHeight, backgroundColor: new RGBA_Bytes(RGBA_Bytes.White, 220), drawFromHintedCach: true);
                currentTextHeight -= 20;
            }

            RoundedRect BackGround2 = new RoundedRect(renderOffset.x, renderOffset.y - 1, renderOffset.x + graphWidth, renderOffset.y - 1 + graphHeight + 2, 5);
            Stroke      StrockedTransformedBackGround = new Stroke(BackGround2);

            graphics2D.Render(StrockedTransformedBackGround, new RGBA_Bytes(0.0, 0, 0, 1));

            //renderer.Color = BoxColor;
            //renderer.DrawRect(m_Position.x, m_Position.y - 1, m_Width, m_Height + 2);

            base.OnDraw(graphics2D);
        }