Esempio n. 1
0
        public void LoadUseageData(IEnumerable <UsageStatisticsDataRow> statisticsData)
        {
            var colourNumber  = 0;
            var seriesToGraph = new List <GraphSeries>();

            foreach (var s in statisticsData)
            {
                var pageName = s.PageName;
                ShowSeries.Add(pageName);
                var series = new GraphSeries(pageName)
                {
                    GraphColour =
                        ColorTranslator.FromHtml("#" + GraphingColours.ColourValues[colourNumber]),
                    Displayed = true
                };
                series.Xvalue.Add(pageName);
                series.Yvalue.Add(s.PageRequests);

                seriesToGraph.Add(series);



                colourNumber++;
            }

            GraphInformation.SeriesData = seriesToGraph;
        }
Esempio n. 2
0
 public GraphPt(GraphSeries <T> series, T value, float x, float y)
 {
     Value  = value;
     X      = x;
     Y      = y;
     Series = series;
 }
Esempio n. 3
0
        /// <summary>
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnShown(object sender, EventArgs e)
        {
            RefreshTimer.Enabled = true;

            Program.NetClient.OnServerStateRecieved += ServerStateRecieved;
            Program.NetClient.RequestServerState();

            TagBuilder.OnTagClicked    += TagItemClicked;
            TagBuilder.OnTagsRefreshed += ValidateState;
            TagBuilder.Attach(addTagToolStripMenuItem);

            if (BandwithGraph.Series.Length == 0 || BandwithGraph.Series[0] == null)
            {
                GraphSeries series = new GraphSeries();
                series.Name                = "Bandwidth Usage";
                series.SlidingWindow       = true;
                series.XAxis.MinLabel      = "";
                series.XAxis.MaxLabel      = "5 Minutes";
                series.XAxis.Min           = 0;
                series.XAxis.Max           = 5 * 60;
                series.XAxis.GridInterval  = 30;
                series.YAxis.MinLabel      = "";
                series.YAxis.MaxLabel      = "1 KB/s";
                series.YAxis.AutoAdjustMax = true;
                series.YAxis.FormatMaxLabelAsTransferRate = true;
                series.MinimumInterval    = 1.0f / 2.0f;
                series.YAxis.Max          = 1024L;
                series.YAxis.GridInterval = series.YAxis.Max / 5;
                BandwithGraph.Series      = new GraphSeries[1] {
                    series
                };
            }
        }
Esempio n. 4
0
        private static VertexArray CreatePointSeriesVao(GraphSeries <T> series)
        {
            // hacky, buffer-based approach. Should be doing diffs/deltas here.
            var count    = series.Points.Count;
            var capacity = (count * _stride).NextPowerOf2();
            var posData  = new Vector2[capacity];
            var uvData   = new Vector2[capacity];

            for (var i = 0; i < count; i++)
            {
                var p = series.Points[i].Position;
                for (int j = 0; j < _uvPositions.Length; j++)
                {
                    posData[i * _stride + j] = p;
                    uvData[i * _stride + j]  = _uvPositions[j];
                }
            }

            var positions = GLFactory.Buffer.ArrayBuffer("Positions", posData);
            var uvs       = GLFactory.Buffer.ArrayBuffer("Uvs", uvData);

            positions.ElementCount = count * _stride;
            var vao = GLFactory.VertexArray.FromBuffers($"Series '{series.Name}'", positions, uvs);

            return(vao);
        }
        public void LoadChart(List <FleetStatusRow> fsd, PercentageDivisorType percentType)
        {
            var seriesList = new List <GraphSeries>();

            hfPercentageValues.Value = percentType.ToString();

            var topics = Enum.GetValues(typeof(AvailabilityTopic));

            ShowSeries.Add(TopicTranslation.GetAvailabilityTopicDescription(AvailabilityTopic.Utilization));
            ShowSeries.Add(TopicTranslation.GetAvailabilityTopicDescription(AvailabilityTopic.OnRent));

            foreach (AvailabilityTopic t in topics)
            {
                if (percentType == PercentageDivisorType.Values)
                {
                    if (t == AvailabilityTopic.Utilization || t == AvailabilityTopic.UtilizationInclOverdue)
                    {
                        continue;
                    }
                }
                else
                {
                    if (t == AvailabilityTopic.OnRent)
                    {
                        continue;
                    }
                }
                var seriesName    = TopicTranslation.GetAvailabilityTopicDescription(t);
                var displaySeries = false;
                if (ShowSeries.Count == 0)
                {
                    if (t == AvailabilityTopic.Utilization || t == AvailabilityTopic.OnRent)
                    {
                        displaySeries = true;
                    }
                }
                else
                {
                    displaySeries = ShowSeries.Contains(seriesName);
                }

                var gs = new GraphSeries(seriesName)
                {
                    GraphColour = TopicTranslation.GetAvailabilityColour(t),
                    Displayed   = displaySeries
                };
                foreach (var f in fsd)
                {
                    gs.Xvalue.Add(f.Day);

                    var yVal = percentType == PercentageDivisorType.Values ? f.GetValue(t) : f.GetValuePercent(t);

                    gs.Yvalue.Add(yVal);
                }
                seriesList.Add(gs);
            }

            GraphInformation.SeriesData = seriesList;
        }
Esempio n. 6
0
        private static unsafe void UpdatePointSeriesVao(VertexArray vao, GraphSeries <T> series)
        {
            var count    = series.Points.Count;
            var capacity = vao.ElementCount.NextPowerOf2();

            var pointsBuffer     = vao.Buffers[0];
            var uvBuffer         = vao.Buffers[1];
            var offsetBytes      = new IntPtr(vao.ElementCount * sizeof(Vector2));
            var missingElemCount = count - (pointsBuffer.ElementCount / _stride);

            if (series.InvalidateRenderCache || (count * _stride) > capacity)
            {
                // reallocate the buffer:
                capacity = (count * _stride).NextPowerOf2();
                var posData = new Vector2[capacity];
                var uvData  = new Vector2[capacity];
                for (var i = 0; i < count; i++)
                {
                    var p = series.Points[i].Position;
                    for (int j = 0; j < _uvPositions.Length; j++)
                    {
                        posData[i * _stride + j] = p;
                        uvData[i * _stride + j]  = _uvPositions[j];
                    }
                }
                GL.BindBuffer(BufferTarget.ArrayBuffer, pointsBuffer.Handle);
                GL.BufferData(BufferTarget.ArrayBuffer, capacity * sizeof(Vector2), posData, BufferUsageHint.StaticDraw);
                GL.BindBuffer(BufferTarget.ArrayBuffer, uvBuffer.Handle);
                GL.BufferData(BufferTarget.ArrayBuffer, capacity * sizeof(Vector2), uvData, BufferUsageHint.StaticDraw);
                GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
                pointsBuffer.ElementCount = count * _stride;
            }
            else
            {
                var sizeBytes = missingElemCount * sizeof(Vector2) * _stride;
                var posData   = new Vector2[missingElemCount * _stride];
                var uvData    = new Vector2[missingElemCount * _stride];
                for (var i = 0; i < missingElemCount; i++)
                {
                    var srcIdx = (pointsBuffer.ElementCount / _stride) + i;
                    var p      = series.Points[srcIdx].Position;

                    for (int j = 0; j < _uvPositions.Length; j++)
                    {
                        posData[i * _stride + j] = p;
                        uvData[i * _stride + j]  = _uvPositions[j];
                    }
                }
                GL.BindBuffer(BufferTarget.ArrayBuffer, pointsBuffer.Handle);
                GL.BufferSubData(BufferTarget.ArrayBuffer, offsetBytes, sizeBytes, posData);
                GL.BindBuffer(BufferTarget.ArrayBuffer, uvBuffer.Handle);
                GL.BufferSubData(BufferTarget.ArrayBuffer, offsetBytes, sizeBytes, uvData);
                GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            }
            pointsBuffer.ElementCount    = (count * _stride);
            series.InvalidateRenderCache = false;
        }
Esempio n. 7
0
        private GraphSeries SeriesFromCollector(CollectorHost collector, Color seriesColor, int lastXEntries)
        {
            GraphSeries series = null;

            if (txtTextFilter.Text.Trim().Length < 2 || collector.PathWithoutMP.ContainEx(txtTextFilter.Text))
            //if (txtTextFilter.Text.Trim().Length < 2 || collector.PathWithoutMP.ToLower().Contains(txtTextFilter.Text.ToLower()))
            {
                string stateValue = "";
                float  v          = 0;
                if (lastXEntries == 0)
                {
                    lastXEntries = collector.StateHistory.Count;
                }
                series = new GraphSeries(collector.PathWithoutMP, seriesColor);
                foreach (MonitorState agentState in (from hsm in collector.StateHistory
                                                     orderby hsm.Timestamp descending
                                                     select hsm).Take(lastXEntries))
                {
                    v          = 0;
                    stateValue = agentState.ReadFirstValue(false);
                    if (stateValue != null && float.TryParse(stateValue, out v))
                    {
                        series.Values.Add(new TimeValue()
                        {
                            Time = agentState.Timestamp, Value = v
                        });
                    }
                }
                v          = 0;
                stateValue = collector.CurrentState.ReadFirstValue(false);
                if (stateValue != null && float.TryParse(stateValue, out v))
                {
                    series.Values.Add(new TimeValue()
                    {
                        Time = collector.CurrentState.Timestamp, Value = v
                    });
                }
            }
            if (series != null && series.Values != null && series.Values.Count > 0)
            {
                return(series);
            }
            //else if (series.Values.Count ==1)
            //{
            //    series.Name += " (Not enough data)";
            //    return series;
            //}
            else
            {
                return(null);
            }
        }
        private void LoadDifferenceChart(IEnumerable <ForecastedFleetSizeEntity> setA, IEnumerable <ForecastedFleetSizeEntity> setB)
        {
            var seriesList = new List <GraphSeries>();

            var series = new List <string> {
                "Forecast Demand Gap", "Demand Gap Scenario A", "Demand Gap Scenario B"
            };

            ShowSeries.AddRange(series.ToArray());

            var expectedSeries = new GraphSeries(series[0])
            {
                GraphColour = Color.DarkGreen,
                Displayed   = true
            };

            var expectedWithAddsA = new GraphSeries(series[1])
            {
                GraphColour = Color.DarkOrchid,
                Displayed   = true
            };

            var expectedWithAddsB = new GraphSeries(series[2])
            {
                GraphColour = Color.OrangeRed,
                Displayed   = true
            };

            foreach (var f in setA)
            {
                expectedSeries.Xvalue.Add(f.Week);
                expectedSeries.Yvalue.Add(((double)f.ExpectedFleet - f.UnConstrained));
                expectedWithAddsA.Xvalue.Add(f.Week);
                expectedWithAddsA.Yvalue.Add((double)f.ExpectedWithAdditionPlan - f.UnConstrained);
            }


            foreach (var f in setB)
            {
                expectedWithAddsB.Xvalue.Add(f.Week);
                expectedWithAddsB.Yvalue.Add((double)f.ExpectedWithAdditionPlan - f.UnConstrained);
            }


            seriesList.Add(expectedSeries);
            seriesList.Add(expectedWithAddsA);
            seriesList.Add(expectedWithAddsB);

            GraphInformation.SeriesData = seriesList;
        }
Esempio n. 9
0
        private GraphSeries AddWaterfallSeries(AvailabilityTopic series, double total, double value, bool show = true)
        {
            var seriesName = TopicTranslation.GetAvailabilityTopicDescription(series);
            var gs         = new GraphSeries(seriesName)
            {
                GraphColour = TopicTranslation.GetAvailabilityColour(series),
                Displayed   = show
            };

            gs.Xvalue.Add(seriesName);

            gs.Yvalue.Add(total);
            gs.Yvalue.Add(total - value);
            return(gs);
        }
Esempio n. 10
0
        public void LoadChart(List <TotalContributionRow> comparisonData)
        {
            if (!comparisonData.Any())
            {
                return;
            }

            var series = new List <string> {
                "Expected Revenue", "Scenario A Revenue", "Scenario B Revenue"
            };

            ShowSeries.AddRange(series.ToArray());

            var expectedSeries = new GraphSeries(series[0])
            {
                GraphColour = Color.DarkGreen,
                Displayed   = true
            };

            var expectedWithAddsA = new GraphSeries(series[1])
            {
                GraphColour = Color.DarkOrchid,
                Displayed   = true
            };

            var expectedWithAddsB = new GraphSeries(series[2])
            {
                GraphColour = Color.OrangeRed,
                Displayed   = true
            };

            foreach (var f in comparisonData)
            {
                var monthName = CultureInfo.CurrentCulture.DateTimeFormat.GetMonthName(f.Month);
                expectedSeries.Xvalue.Add(monthName);
                expectedSeries.Yvalue.Add((f.ExpectedContribution));
                expectedWithAddsA.Xvalue.Add(monthName);
                expectedWithAddsA.Yvalue.Add(f.ExpectedContributionA);
                expectedWithAddsB.Xvalue.Add(monthName);
                expectedWithAddsB.Yvalue.Add(f.ExpectedContributionB);
            }

            var seriesList = new List <GraphSeries> {
                expectedSeries, expectedWithAddsA, expectedWithAddsB
            };

            GraphInformation.SeriesData = seriesList;
        }
Esempio n. 11
0
    protected override void printData(string [] statValues)
    {
        //values are recorded for calculating later AVG and SD
        recordStatValues(statValues);

        //only simpleSession

        int i = 0;

        //we need to save this transposed
        foreach (string myValue in statValues)
        {
            if (i == 0)
            {
                CurrentGraphData.XAxisNames.Add(myValue);
            }
            else if (i == 1)
            {
                serieAVG.SerieData.Add(myValue);
            }
            else if (i == 2)
            {
                serieSD.SerieData.Add(myValue);
            }
            else if (i == 3)
            {
                serieJumps.SerieData.Add(myValue);
            }

            if (i == 3)
            {
                i = 0;
            }
            else
            {
                i++;
            }
        }

        //add created series to GraphSeries ArrayList
        //check don't do it two times
        if (GraphSeries.Count == 0)
        {
            GraphSeries.Add(serieAVG);
            GraphSeries.Add(serieSD);
            GraphSeries.Add(serieJumps);
        }
    }
        public void LoadChart(List <ComparisonRow> comparisonData, ReportType report)
        {
            SessionStringName = string.Format("{0}SessionString", report);

            if (GraphInformation == null)
            {
                GraphInformation = new GraphData();
            }

            var seriesList = new List <GraphSeries>();
            var tf         = new GraphSeries("TotalFleet")
            {
                GraphColour = Color.Blue
            };
            var tnr = new GraphSeries("TotalNonRev")
            {
                GraphColour = Color.Red
            };
            var re = new GraphSeries("Comments")
            {
                GraphColour = Color.Green
            };


            foreach (var cd in comparisonData)
            {
                if (cd.Key == "Total")
                {
                    continue;
                }
                tf.Xvalue.Add(cd.Key);
                tnr.Xvalue.Add(cd.Key);
                re.Xvalue.Add(cd.Key);


                tf.Yvalue.Add(cd.FleetCount);
                tnr.Yvalue.Add(cd.NonRevCount);
                re.Yvalue.Add(cd.ReasonsEntered);
            }
            seriesList.Add(tf);
            seriesList.Add(tnr);
            seriesList.Add(re);

            GraphInformation.SeriesData = seriesList;
        }
Esempio n. 13
0
        /// <summary>
        /// Serializes the chart pie.
        /// </summary>
        /// <param name="graph">The graph.</param>
        /// <returns></returns>
        private static IDictionary <string, object> serializeChartPie(Graph graph)
        {
            ArrayList   arrayList = new ArrayList();
            GraphSeries series    = graph.Series[0];

            Dictionary <string, object> dictValueToObject = new Dictionary <string, object>();

            foreach (GraphAxis graphAxis in series.Axis)
            {
                Dictionary <string, object> dictList = new Dictionary <string, object>();
                dictList.Add("label", graphAxis.X);
                dictList.Add("data", graphAxis.Y);
                arrayList.Add(dictList);
            }

            dictValueToObject.Add("Series", arrayList);
            return(dictValueToObject);
        }
Esempio n. 14
0
    protected override void printData(string [] statValues)
    {
        /*
         * if one day i found the way of plotting different (single plots) i will use it for the numContinuous
         */
        /*
         * if(numContinuous != -1) {
         *      int bestPos = findBestContinuous(statValues, numContinuous);
         *      if(bestPos != -1) {
         *              statValues = markBestContinuous(statValues, numContinuous, bestPos);
         *      }
         * }
         */

        GraphSerie serieTc = new GraphSerie();
        GraphSerie serieTv = new GraphSerie();

        serieTc.IsLeftAxis = true;
        serieTv.IsLeftAxis = true;

        int i = 0;

        foreach (string myValue in statValues)
        {
            if (i == 0)
            {
                serieTc.Title = myValue + " " + Catalog.GetString("TC");
                serieTv.Title = myValue + " " + Catalog.GetString("TF");
            }
            else if (isTC(i))
            {
                serieTc.SerieData.Add(myValue);
            }
            else if (isTF(i))
            {
                serieTv.SerieData.Add(myValue);
            }
            i++;
        }

        //add created series to GraphSeries ArrayList
        GraphSeries.Add(serieTc);
        GraphSeries.Add(serieTv);
    }
Esempio n. 15
0
        private static VertexArray CreateLineSeriesVao(GraphSeries <T> series)
        {
            // hacky, buffer-based approach. Should be doing diffs/deltas here.
            var count    = series.Points.Count;
            var capacity = count.NextPowerOf2();
            var arr      = new Vector2[capacity];

            for (var i = 0; i < count; i++)
            {
                arr[i] = series.Points[i].Position;
            }

            var positions = GLFactory.Buffer.ArrayBuffer("Positions", arr);

            positions.ElementCount = count;
            var vao = GLFactory.VertexArray.FromBuffers($"Series '{series.Name}'", positions);

            return(vao);
        }
Esempio n. 16
0
    protected override void printData(string [] statValues)
    {
        /*
         * if one day i found the way of plotting different (single plots) i will use it for the numContinuous
         */
        /*
         * if(numContinuous != -1) {
         *      int bestPos = findBestContinuous(statValues, numContinuous);
         *      if(bestPos != -1) {
         *              statValues = markBestContinuous(statValues, numContinuous, bestPos);
         *      }
         * }
         */

        GraphSerie serieSpeed = new GraphSerie();

        serieSpeed.IsLeftAxis = true;

        int i = 0;

        foreach (string myValue in statValues)
        {
            if (i == 0)
            {
                serieSpeed.Title = myValue;
            }
            else if (i >= 2)
            {
                serieSpeed.SerieData.Add(myValue);
            }
            //i==1 is the avg speed, is not used

            i++;
        }

        //add created series to GraphSeries ArrayList
        GraphSeries.Add(serieSpeed);
    }
Esempio n. 17
0
        private static unsafe void UpdateLineSeriesVao(VertexArray vao, GraphSeries <T> series)
        {
            var count    = series.Points.Count;
            var capacity = vao.ElementCount.NextPowerOf2();

            var pointsBuffer = vao.Buffers[0];

            GL.BindBuffer(BufferTarget.ArrayBuffer, pointsBuffer.Handle);
            var offsetBytes      = new IntPtr(vao.ElementCount * sizeof(Vector2));
            var missingElemCount = count - pointsBuffer.ElementCount;

            if (series.InvalidateRenderCache || count > capacity)
            {
                // reallocate the buffer:
                capacity = MathHelper.NextPowerOfTwo(count);
                var allData = new Vector2[capacity];
                for (var i = 0; i < Math.Min(capacity, count); i++)
                {
                    allData[i] = series.Points[i].Position;
                }
                GL.BufferData(BufferTarget.ArrayBuffer, capacity * sizeof(Vector2), allData, BufferUsageHint.StaticDraw);
                pointsBuffer.ElementCount = count;
            }
            else
            {
                var sizeBytes = missingElemCount * sizeof(Vector2);
                var newData   = new Vector2[missingElemCount];
                for (var i = 0; i < missingElemCount; i++)
                {
                    newData[i] = series.Points[pointsBuffer.ElementCount + i].Position;
                }
                GL.BufferSubData(BufferTarget.ArrayBuffer, offsetBytes, sizeBytes, newData);
            }
            GL.BindBuffer(BufferTarget.ArrayBuffer, 0);
            pointsBuffer.ElementCount    = count;
            series.InvalidateRenderCache = false;
        }
Esempio n. 18
0
    protected override void printData(string [] statValues)
    {
        //values are recorded for calculating later AVG and SD
        recordStatValues(statValues);

        if (sessions.Count == 1)
        {
            int  i        = 0;
            bool foundAVG = false;
            //we need to save this transposed
            foreach (string myValue in statValues)
            {
                if (i == 0)
                {
                    //don't plot AVG and SD rows
                    if (myValue == Catalog.GetString("AVG"))
                    {
                        foundAVG = true;
                    }
                    else
                    {
                        CurrentGraphData.XAxisNames.Add(myValue);
                    }
                }
                else if (i == 1)
                {
                    if (foundAVG)
                    {
                        serieIndex.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieIndex.SerieData.Add(myValue);
                    }
                }
                else if (i == 2)
                {
                    if (foundAVG)
                    {
                        serieTv.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieTv.SerieData.Add(myValue);
                    }
                }
                else if (i == 3)
                {
                    if (foundAVG)
                    {
                        serieTc.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieTc.SerieData.Add(myValue);
                    }
                }
                else if (i == 4)
                {
                    //correct jumps and time for being displayed
                    if (foundAVG)
                    {
                        //serieJumps.Avg = Convert.ToDouble(myValue) *10;
                        serieJumps.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        //serieJumps.SerieData.Add( (Convert.ToDouble(myValue) *10).ToString() );
                        serieJumps.SerieData.Add(myValue);
                    }
                }
                else if (i == 5)
                {
                    //correct jumps and time for being displayed
                    if (foundAVG)
                    {
                        //serieTime.Avg = Convert.ToDouble(myValue) * 10;
                        serieTime.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        //serieTime.SerieData.Add( (Convert.ToDouble(myValue) *10).ToString() );
                        serieTime.SerieData.Add(myValue);
                    }
                }
                else if (i == 6)
                {
                    if (foundAVG)
                    {
                        serieFall.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieFall.SerieData.Add(myValue);
                    }
                }

                if (foundAVG && i == dataColumns)
                {
                    //add created series to GraphSeries ArrayList
                    //check don't do it two times
                    if (GraphSeries.Count == 0)
                    {
                        GraphSeries.Add(serieTc);
                        GraphSeries.Add(serieTv);
                        GraphSeries.Add(serieIndex);
                        GraphSeries.Add(serieJumps);
                        GraphSeries.Add(serieTime);
                        GraphSeries.Add(serieFall);
                    }
                    return;
                }

                i++;
            }
        }
        else
        {
            GraphSerie mySerie = new GraphSerie();
            mySerie.IsLeftAxis = true;

            int i = 0;
            foreach (string myValue in statValues)
            {
                if (myValue == Catalog.GetString("SD"))
                {
                    return;
                }

                if (i == 0)
                {
                    mySerie.Title = myValue;
                }
                else if (i == sessions.Count + 1)                    //eg, for 2 sessions: [(0)person name, (1)sess1, (2)sess2, (3)AVG]
                {
                    if (myValue != "-")
                    {
                        mySerie.Avg = Convert.ToDouble(myValue);
                    }
                }
                else
                {
                    mySerie.SerieData.Add(myValue);
                }

                i++;
            }
            GraphSeries.Add(mySerie);
        }
    }
Esempio n. 19
0
        private void LoadControls(bool reloadList = false)
        {
            DateTime fromTime          = fromDateTimeChooser.SelectedDateTime;
            DateTime toTime            = toDateTimeChooser.SelectedDateTime;
            DateTime autoStartDateTime = DateTime.Now.AddMinutes(-1);
            DateTime autoEndDateTime   = DateTime.Now;

            long               initialMax      = (long)nudinitialMax.Value;
            long               maxValue        = 1;
            List <string>      seriesNames     = new List <string>();
            List <GraphSeries> graphSeriesList = new List <GraphSeries>();

            if (reloadList)
            {
                List <ListViewItem> list = new List <ListViewItem>();
                foreach (CollectorHost collector in SelectedCollectors)
                {
                    string       itemName = $"{collector.PathWithoutMP}";
                    ListViewItem itm      = new ListViewItem(itemName);
                    itm.Tag = collector;
                    try
                    {
                        if (collector.CurrentState != null)
                        {
                            itm.SubItems.Add(collector.CurrentState.ReadPrimaryOrFirstUIValue());
                        }
                        else
                        {
                            itm.SubItems.Add("");
                        }
                        itm.ImageIndex = GetItemIcon(collector);
                    }
                    catch (Exception ex)
                    {
                        itm.SubItems.Add(ex.Message);
                        itm.ImageIndex = 10;
                    }
                    list.Add(itm);
                }
                lvwCollectorStates.Items.Clear();
                lvwCollectorStates.Items.AddRange(list.ToArray());
            }
            else
            {
                foreach (ListViewItem lvi in lvwCollectorStates.Items)
                {
                    if (lvi.Tag is CollectorHost)
                    {
                        CollectorHost collector = (CollectorHost)lvi.Tag;
                        try
                        {
                            if (collector.CurrentState != null)
                            {
                                lvi.SubItems[1].Text = collector.CurrentState.ReadPrimaryOrFirstUIValue();
                            }
                            else
                            {
                                lvi.SubItems[1].Text = "";
                            }
                            lvi.ImageIndex = GetItemIcon(collector);
                        }
                        catch (Exception ex)
                        {
                            lvi.SubItems[1].Text = ex.Message;
                            lvi.ImageIndex       = 10;
                        }
                    }
                }
            }

            //Making seriesses
            foreach (CollectorHost collector in SelectedCollectors)
            {
                Color       seriesColor = seriesColors[graphSeriesList.Count % seriesColors.Count];
                GraphSeries series      = SeriesFromCollector(collector, seriesColor, (int)nudLastXEntries.Value);
                if (series != null)
                {
                    seriesNames.Add(series.Name);
                    float val = series.Values.OrderByDescending(v => v.Value).FirstOrDefault().Value;
                    if (maxValue < val)
                    {
                        maxValue = (long)val;
                    }
                    DateTime firstTime = series.Values.OrderBy(v => v.Time).FirstOrDefault().Time;
                    if (autoStartDateTime > firstTime)
                    {
                        autoStartDateTime = firstTime;
                    }
                    graphSeriesList.Add(series);
                }
            }

            if (chkAutoFromTime.Checked)
            {
                fromTime = DateTime.Now;
                foreach (CollectorHost collector in SelectedCollectors)
                {
                    if (collector.StateHistory != null && collector.StateHistory.Count > 0)
                    {
                        MonitorState mp = collector.StateHistory.OrderBy(h => h.Timestamp).FirstOrDefault();
                        if (fromTime > mp.Timestamp)
                        {
                            fromTime = mp.Timestamp;
                        }
                    }
                }
                fromDateTimeChooser.SelectedDateTime = fromTime;
            }
            if (chkAutoToTime.Checked)
            {
                toTime = DateTime.Now;
                toDateTimeChooser.SelectedDateTime = toTime;
            }


            collectorTimeGraph.PauseUpdates();
            collectorTimeGraph.StartDateTime = fromTime;
            collectorTimeGraph.EndDateTime   = toTime;
            collectorTimeGraph.MaxGraphValue = initialMax;
            collectorTimeGraph.Series        = graphSeriesList;
            if (graphSeriesList == null || graphSeriesList.Count == 0)
            {
                collectorTimeGraph.GraphHeaderText = "No Series!";
                Text = $"Collector Graph";
            }
            else if (graphSeriesList.Count == 1)
            {
                collectorTimeGraph.GraphHeaderText = graphSeriesList[0].Name;
                Text = $"Collector Graph - {graphSeriesList[0].Name}";
            }
            else
            {
                collectorTimeGraph.GraphHeaderText = $"Collectors graph";
                Text = $"Collector Graph";
            }
            collectorTimeGraph.SetAutoMinMaxDateTimes(chkAutoFromTime.Checked, chkAutoToTime.Checked, chkAutoMaxValue.Checked);

            //collectorTimeGraph.BackgroundGradientColor1 = Properties.Settings.Default.GraphBackgroundColor1;
            //collectorTimeGraph.BackgroundGradientColor2 = Properties.Settings.Default.GraphBackgroundColor2;
            //collectorTimeGraph.GridColor = Properties.Settings.Default.GraphGridColor;
            //collectorTimeGraph.AxisLabelColor = Properties.Settings.Default.GraphAxisLabelsColor;
            //collectorTimeGraph.TimeSelectionColor = Properties.Settings.Default.GraphSelectionBarColor;
            ////collectorTimeGraph.GraphVerticalAxisType = (GraphVerticalAxisType)Properties.Settings.Default.GraphDefaultType;
            //collectorTimeGraph.GradientDirection = (System.Drawing.Drawing2D.LinearGradientMode)Properties.Settings.Default.GraphGradientDirection;
            //collectorTimeGraph.ClosestClickedValueColorType = (ClosestClickedValueColorType)Properties.Settings.Default.GraphClosestClickedValueType;
            //collectorTimeGraph.ClosestClickedValueCustomColor = Properties.Settings.Default.GraphClosestClickedValueColor;

            //collectorTimeGraph.ShowGraphHeader = Properties.Settings.Default.GraphHeaderVisible;
            //collectorTimeGraph.ShowLegendText = Properties.Settings.Default.GraphLegendVisible;
            //collectorTimeGraph.ShowHorisontalGridlines = Properties.Settings.Default.GraphHorisontalGridLinesVisible;
            //collectorTimeGraph.ShowVerticalGridLines = Properties.Settings.Default.GraphVerticalGridLinesVisible;
            //collectorTimeGraph.ShowSelectionBar = Properties.Settings.Default.GraphSelectionBarVisible;
            //collectorTimeGraph.HighlightClickedSeries = Properties.Settings.Default.GraphHighlightClickedSeriesVisible;
            //collectorTimeGraph.FillAreaBelowGraph = Properties.Settings.Default.GraphEnableFillAreaBelowSeries;
            //collectorTimeGraph.FillAreaBelowGraphAlpha = Properties.Settings.Default.GraphFillAreaBelowSeriesAlpha;

            this.Invoke((MethodInvoker) delegate
            {
                collectorTimeGraph.RefreshGraph();
            });
        }
        private void LoadValuesChart(IEnumerable <ForecastedFleetSizeEntity> setA, IEnumerable <ForecastedFleetSizeEntity> setB)
        {
            var seriesList = new List <GraphSeries>();

            var series = new List <string> {
                "Expected", "Unconstrained", "Nessesary"
                , "Max A", "Min A", "Expected With Adds A", "Max B", "Min B", "Expected With Adds B"
            };

            ShowSeries.AddRange(series.ToArray());

            var expectedSeries = new GraphSeries(series[0])
            {
                GraphColour = Color.DarkGreen,
                Displayed   = true
            };

            var unconstrainedSeries = new GraphSeries(series[1])
            {
                GraphColour = Color.CornflowerBlue,
                Displayed   = true
            };

            var nessesarySeries = new GraphSeries(series[2])
            {
                GraphColour = Color.Brown,
                Displayed   = true
            };

            var maxSeriesA = new GraphSeries(series[3])
            {
                GraphColour = Color.Magenta,
                Displayed   = false
            };

            GraphInformation.HiddenSeriesNames.Add(series[3]);

            var minSeriesA = new GraphSeries(series[4])
            {
                GraphColour = Color.Magenta,
                Displayed   = false
            };

            GraphInformation.HiddenSeriesNames.Add(series[4]);

            var expectedWithAddsA = new GraphSeries(series[5])
            {
                GraphColour = Color.DarkOrchid,
                Displayed   = true
            };


            var maxSeriesB = new GraphSeries(series[6])
            {
                GraphColour = Color.Orange,
                Displayed   = false
            };

            GraphInformation.HiddenSeriesNames.Add(series[6]);


            var minSeriesB = new GraphSeries(series[7])
            {
                GraphColour = Color.Orange,
                Displayed   = false
            };

            GraphInformation.HiddenSeriesNames.Add(series[7]);

            var expectedWithAddsB = new GraphSeries(series[8])
            {
                GraphColour = Color.OrangeRed,
                Displayed   = true
            };

            foreach (var f in setA)
            {
                expectedSeries.Xvalue.Add(f.Week);
                unconstrainedSeries.Xvalue.Add(f.Week);
                nessesarySeries.Xvalue.Add(f.Week);
                maxSeriesA.Xvalue.Add(f.Week);
                minSeriesA.Xvalue.Add(f.Week);

                expectedSeries.Yvalue.Add((double)f.ExpectedFleet);
                unconstrainedSeries.Yvalue.Add(f.UnConstrained);
                nessesarySeries.Yvalue.Add(f.Nessesary);
                maxSeriesA.Yvalue.Add(f.MaxFleet);
                minSeriesA.Yvalue.Add(f.MinFleet);
                expectedWithAddsA.Xvalue.Add(f.Week);
                expectedWithAddsA.Yvalue.Add((double)f.ExpectedWithAdditionPlan);
            }


            foreach (var f in setB)
            {
                maxSeriesB.Xvalue.Add(f.Week);
                minSeriesB.Xvalue.Add(f.Week);
                maxSeriesB.Yvalue.Add(f.MaxFleet);
                minSeriesB.Yvalue.Add(f.MinFleet);
                expectedWithAddsB.Xvalue.Add(f.Week);
                expectedWithAddsB.Yvalue.Add((double)f.ExpectedWithAdditionPlan);
            }


            seriesList.Add(expectedSeries);
            seriesList.Add(unconstrainedSeries);
            seriesList.Add(nessesarySeries);
            seriesList.Add(maxSeriesA);
            seriesList.Add(minSeriesA);
            seriesList.Add(maxSeriesB);
            seriesList.Add(minSeriesB);
            seriesList.Add(expectedWithAddsA);
            seriesList.Add(expectedWithAddsB);

            GraphInformation.SeriesData = seriesList;
        }
Esempio n. 21
0
    protected override void printData(string [] statValues)
    {
        //values are recorded for calculating later AVG and SD
        recordStatValues(statValues);

        if (sessions.Count == 1)
        {
            int  i        = 0;
            bool foundAVG = false;
            //we need to save this transposed
            foreach (string myValue in statValues)
            {
                if (i == 0)
                {
                    //don't plot AVG and SD rows
                    if (myValue == Catalog.GetString("AVG"))
                    {
                        foundAVG = true;
                    }
                    else
                    {
                        CurrentGraphData.XAxisNames.Add(myValue);
                    }
                }
                else if (i == 1)
                {
                    if (foundAVG)
                    {
                        serieIndex.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieIndex.SerieData.Add(myValue);
                    }
                }
                else if (i == 2)
                {
                    if (foundAVG)
                    {
                        serieJump1.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieJump1.SerieData.Add(myValue);
                    }
                }
                else if (i == 3)
                {
                    if (foundAVG)
                    {
                        serieJump2.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieJump2.SerieData.Add(myValue);
                    }
                }

                if (foundAVG && i == dataColumns)
                {
                    //add created series to GraphSeries ArrayList
                    //check don't do it two times
                    if (GraphSeries.Count == 0)
                    {
                        GraphSeries.Add(serieJump1);
                        GraphSeries.Add(serieJump2);
                        GraphSeries.Add(serieIndex);
                    }
                    return;
                }

                i++;
            }
        }
        else
        {
            GraphSerie mySerie = new GraphSerie();
            mySerie.IsLeftAxis = true;

            int i = 0;
            foreach (string myValue in statValues)
            {
                if (myValue == Catalog.GetString("AVG") || myValue == Catalog.GetString("SD"))
                {
                    return;
                }
                if (i == 0)
                {
                    mySerie.Title = myValue;
                }
                else
                {
                    mySerie.SerieData.Add(myValue);
                }
                i++;
            }
            GraphSeries.Add(mySerie);
        }
    }
Esempio n. 22
0
    protected override void printData(string [] statValues)
    {
        if (sessions.Count == 1)
        {
            int i = 0;
            //we need to save this transposed
            string myValueBefore = "";
            foreach (string myValue in statValues)
            {
                if (i == 0)
                {
                    //don't plot AVG and SD rows
                    if (myValue == Catalog.GetString("AVG") || myValue == Catalog.GetString("SD"))
                    {
                        return;
                    }

                    //global is nicer and cleaner  without the AVG and SD
                    if (GraphSeries.Count == 0)
                    {
                        GraphSeries.Add(serieTv);
                        GraphSeries.Add(serieIndex);
                    }

                    /*
                     * //don't plot AVG and SD rows
                     * if( myValue == Catalog.GetString("AVG") || myValue == Catalog.GetString("SD") ) {
                     *      //good moment for adding created series to GraphSeries ArrayList
                     *      //check don't do it two times
                     *      if(GraphSeries.Count == 0) {
                     *              GraphSeries.Add(serieIndex);
                     *              GraphSeries.Add(serieTv);
                     *      }
                     *      return;
                     * }
                     */

                    if (myValue.StartsWith("IndexQ"))
                    {
                        CurrentGraphData.XAxisNames.Add(myValue.Replace("IndexQ", "IndexQ *10"));
                    }
                    else if (myValue == "FV")
                    {
                        CurrentGraphData.XAxisNames.Add(myValue.Replace("FV", "FV *10"));
                    }
                    else
                    {
                        CurrentGraphData.XAxisNames.Add(myValue);
                    }

                    //record the statistic (stripping of sex)
                    string [] stringFullResults = myValue.Split(new char[] { '.' });
                    myValueBefore = stringFullResults[0];
                }
                else
                {
                    if (myValueBefore.StartsWith("DjIndex") ||
                        myValueBefore.StartsWith("RjIndex") || myValueBefore.StartsWith(Constants.RJPotencyBoscoName) ||
                        myValueBefore == "IE" || myValueBefore == Constants.ArmsUseIndexName)
                    {
                        serieIndex.SerieData.Add(myValue);
                        //serieTv.SerieData.Add("-");
                    }
                    else if (myValueBefore.StartsWith("IndexQ") || myValueBefore == "FV")
                    {
                        serieIndex.SerieData.Add((
                                                     Convert.ToDouble(myValue) * 10).ToString());
                        //serieTv.SerieData.Add("-");
                    }
                    else
                    {
                        serieTv.SerieData.Add(myValue);
                        //serieIndex.SerieData.Add("-");
                    }
                }
                i++;
            }
        }
        else
        {
            GraphSerie mySerie = new GraphSerie();

            int    i             = 0;
            string myValueBefore = "";
            foreach (string myValue in statValues)
            {
                if (myValue == Catalog.GetString("AVG") || myValue == Catalog.GetString("SD"))
                {
                    return;
                }
                if (i == 0)
                {
                    //strip of sex
                    string [] stringFullResults = myValue.Split(new char[] { '.' });
                    string    valueNoSex        = stringFullResults[0];

                    if (valueNoSex.StartsWith("DjIndex") || valueNoSex.StartsWith("IndexQ") ||
                        valueNoSex.StartsWith("RjIndex") || valueNoSex.StartsWith(Constants.RJPotencyBoscoName) ||
                        valueNoSex == "IE" || valueNoSex == Constants.ArmsUseIndexName || valueNoSex == "FV")
                    {
                        mySerie.IsLeftAxis = false;
                    }
                    else
                    {
                        mySerie.IsLeftAxis = true;
                    }
                    myValueBefore = valueNoSex;                     //for changing later indexQ for indexQ*10
                    mySerie.Title = myValue;
                }
                else
                {
                    if (myValueBefore.StartsWith("IndexQ"))
                    {
                        if (myValue == "-")
                        {
                            mySerie.SerieData.Add(myValue);
                        }
                        else
                        {
                            mySerie.SerieData.Add((
                                                      Convert.ToDouble(myValue) * 10).ToString());
                        }
                        mySerie.Title = myValueBefore.Replace("IndexQ", "IndexQ *10");
                    }
                    else if (myValueBefore == "FV")
                    {
                        if (myValue == "-")
                        {
                            mySerie.SerieData.Add(myValue);
                        }
                        else
                        {
                            mySerie.SerieData.Add((
                                                      Convert.ToDouble(myValue) * 10).ToString());
                        }
                        mySerie.Title = myValueBefore.Replace("FV", "FV *10");
                    }
                    else
                    {
                        mySerie.SerieData.Add(myValue);
                    }
                }
                i++;
            }
            GraphSeries.Add(mySerie);
        }
    }
Esempio n. 23
0
    protected override void printData(string [] statValues)
    {
        //values are recorded for calculating later AVG and SD
        recordStatValues(statValues);

        if (sessions.Count == 1)
        {
            int  i        = 0;
            bool foundAVG = false;
            //we need to save this transposed
            foreach (string myValue in statValues)
            {
                if (i == 0)
                {
                    if (myValue == Catalog.GetString("AVG"))
                    {
                        foundAVG = true;
                    }
                    else
                    {
                        CurrentGraphData.XAxisNames.Add(myValue);
                    }
                }
                else if (i == 1)
                {
                    if (foundAVG)
                    {
                        serieResultPercent.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieResultPercent.SerieData.Add(myValue);
                    }
                    //2 is result and is not plotted
                }
                else if (i == 3)
                {
                    if (foundAVG)
                    {
                        serieJump1.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieJump1.SerieData.Add(myValue);
                    }
                }
                else if (i == 4)
                {
                    if (foundAVG)
                    {
                        serieJump2.Avg = Convert.ToDouble(myValue);
                    }
                    else
                    {
                        serieJump2.SerieData.Add(myValue);
                    }
                }

                if (foundAVG && i == dataColumns)
                {
                    //add created series to GraphSeries ArrayList
                    //check don't do it two times
                    if (GraphSeries.Count == 0)
                    {
                        GraphSeries.Add(serieJump1);
                        GraphSeries.Add(serieJump2);
                        GraphSeries.Add(serieResultPercent);
                    }
                    return;
                }

                i++;
            }
        }
        else
        {
            GraphSerie mySerie = new GraphSerie();
            mySerie.IsLeftAxis = true;

            int i = 0;
            foreach (string myValue in statValues)
            {
                if (myValue == Catalog.GetString("SD"))
                {
                    return;
                }

                if (i == 0)
                {
                    mySerie.Title = myValue;
                }
                else if (i == sessions.Count + 1)                    //eg, for 2 sessions: [(0)person name, (1)sess1, (2)sess2, (3)AVG]
                {
                    if (myValue != "-")
                    {
                        mySerie.Avg = Convert.ToDouble(myValue);
                    }
                }
                else
                {
                    mySerie.SerieData.Add(myValue);
                }

                i++;
            }
            GraphSeries.Add(mySerie);
        }
    }