Added -show_detector_state which show the detector state in the total bitrate graph.

webrtc/rtc_tools/event_log_visualizer/plot_base.h

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #ifndef WEBRTC_RTC_TOOLS_EVENT_LOG_VISUALIZER_PLOT_BASE_H_
@@ skipping 22 matching lines @@
 };
 
 struct TimeSeries {
   TimeSeries() = default;
   TimeSeries(const char* label, PlotStyle style) : label(label), style(style) {}
   TimeSeries(const std::string& label, PlotStyle style)
       : label(label), style(style) {}
   TimeSeries(TimeSeries&& other)
       : label(std::move(other.label)),
         style(other.style),
+        color(other.color),
         points(std::move(other.points)) {}
   TimeSeries& operator=(TimeSeries&& other) {
     label = std::move(other.label);
     style = other.style;
+    color = other.color;
     points = std::move(other.points);
     return *this;
   }
 
   std::string label;
   PlotStyle style;
+  std::string color;

[terelius, 2017/07/04 12:22:01]

This is not used as far as I can tell. Furthermore, I still would like to
separate the data from the visualization details like color.

[philipel, 2017/07/04 12:55:10]

Removed.

Not sure I understand what you mean by separating data from visualization. Both
TimeSeries and Interval is a generalization of different types of data for the
sole purpose of visualizing it, so in my mind these classes IS the separation.

Of course, if you don't care about the color then it's nice that you don't have
to specify it.

[terelius, 2017/07/07 13:42:01]

What I mean is that "connect these point with a line" is something that only
depends on the data, and can be carried out by any visualization framework. The
choice of color is not part of the data and different visualization frameworks
may or may not be able to do it. Furthermore, many frameworks choose fairly
sophisticated color schemes to make sure that different curves are
distinguishable without making the colors clash. If we specify colors for some
but not all data, we're going to clash with the color scheme of the
visualization framework. On the other hand, specifying colors for all data
series would duplicate a lot of the complex logic that's already (and more
appropriately) done in the visualization framework.

Hence, I don't think we should be able to specify any colors at all.

[philipel, 2017/07/11 14:12:35]

To represent some data using a LINE_GRAPH, LINE_DOT_GRAPH or a BAR_GRAPH is a
choice made by the programmer on how to visualize the data. Choosing some color
for that specific data is just another decision about how it should be
visualized.
Not having to specify color for a given graph and having the framework choose it
for you is convenient, but for some situations (like this) it will not give you
a good result. In this case you want to have lighter background colors that
doesn't interfere with the drawn graphs, and it is also a plus to have
consistent colors so that overuse is always represented by red and underuse by
blue for example.

   std::vector<TimeSeriesPoint> points;
 };
 
+struct Interval {
+  Interval() = default;
+  Interval(double begin, double end) : begin(begin), end(end) {}
+
+  double begin;
+  double end;
+};
+
+struct IntervalSeries {
+  enum Orientation { kHorizontal, kVertical };
+
+  IntervalSeries() = default;
+  IntervalSeries(const std::string& label,
+                 const std::string& color,
+                 IntervalSeries::Orientation orientation)
+      : label(label), color(color), orientation(orientation) {}
+
+  std::string label;
+  std::string color;
+  Orientation orientation;
+  std::vector<Interval> intervals;
+};
+
 // A container that represents a general graph, with axes, title and one or
 // more data series. A subclass should define the output format by overriding
 // the Draw() method.
 class Plot {
  public:
   virtual ~Plot() {}
 
   // Overloaded to draw the plot.
   virtual void Draw() = 0;
 
@@ skipping 36 matching lines @@
                          std::string label,
                          float bottom_margin = 0,
                          float top_margin = 0);
 
   // Sets the title of the plot.
   void SetTitle(std::string title);
 
   // Add a new TimeSeries to the plot.
   void AppendTimeSeries(TimeSeries&& time_series);
 
+  // Add a new IntervalSeries to the plot.
+  void AppendIntervalSeries(IntervalSeries&& interval_series);
+
   // Add a new TimeSeries to the plot if the series contains contains data.
   // Otherwise, the call has no effect and the timeseries is destroyed.
   void AppendTimeSeriesIfNotEmpty(TimeSeries&& time_series);
 
  protected:
   float xaxis_min_;
   float xaxis_max_;
   std::string xaxis_label_;
   float yaxis_min_;
   float yaxis_max_;
   std::string yaxis_label_;
   std::string title_;
   std::vector<TimeSeries> series_list_;
+  std::vector<IntervalSeries> interval_list_;
 };
 
 class PlotCollection {
  public:
   virtual ~PlotCollection() {}
   virtual void Draw() = 0;
   virtual Plot* AppendNewPlot() = 0;
 
  protected:
   std::vector<std::unique_ptr<Plot> > plots_;
 };
 
 }  // namespace plotting
 }  // namespace webrtc
 
 #endif  // WEBRTC_RTC_TOOLS_EVENT_LOG_VISUALIZER_PLOT_BASE_H_