Adam / webapp_admin

Blame view

static/plugins/flot/jquery.flot.threshold.js 4.38 KB
edit raw normal view history
831eac332   zhuzhenchao   add file 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
  /* Flot plugin for thresholding data.
  
  Copyright (c) 2007-2013 IOLA and Ole Laursen.
  Licensed under the MIT license.
  
  The plugin supports these options:
  
  	series: {
  		threshold: {
  			below: number
  			color: colorspec
  		}
  	}
  
  It can also be applied to a single series, like this:
  
  	$.plot( $("#placeholder"), [{
  		data: [ ... ],
  		threshold: { ... }
  	}])
  
  An array can be passed for multiple thresholding, like this:
  
  	threshold: [{
  		below: number1
  		color: color1
  	},{
  		below: number2
  		color: color2
  	}]
  
  These multiple threshold objects can be passed in any order since they are
  sorted by the processing function.
  
  The data points below "below" are drawn with the specified color. This makes
  it easy to mark points below 0, e.g. for budget data.
  
  Internally, the plugin works by splitting the data into two series, above and
  below the threshold. The extra series below the threshold will have its label
  cleared and the special "originSeries" attribute set to the original series.
  You may need to check for this in hover events.
  
  */
  
  (function ($) {
      var options = {
          series: { threshold: null } // or { below: number, color: color spec}
      };
      
      function init(plot) {
          function thresholdData(plot, s, datapoints, below, color) {
              var ps = datapoints.pointsize, i, x, y, p, prevp,
                  thresholded = $.extend({}, s); // note: shallow copy
  
              thresholded.datapoints = { points: [], pointsize: ps, format: datapoints.format };
              thresholded.label = null;
              thresholded.color = color;
              thresholded.threshold = null;
              thresholded.originSeries = s;
              thresholded.data = [];
   
              var origpoints = datapoints.points,
                  addCrossingPoints = s.lines.show;
  
              var threspoints = [];
              var newpoints = [];
              var m;
  
              for (i = 0; i < origpoints.length; i += ps) {
                  x = origpoints[i];
                  y = origpoints[i + 1];
  
                  prevp = p;
                  if (y < below)
                      p = threspoints;
                  else
                      p = newpoints;
  
                  if (addCrossingPoints && prevp != p && x != null
                      && i > 0 && origpoints[i - ps] != null) {
                      var interx = x + (below - y) * (x - origpoints[i - ps]) / (y - origpoints[i - ps + 1]);
                      prevp.push(interx);
                      prevp.push(below);
                      for (m = 2; m < ps; ++m)
                          prevp.push(origpoints[i + m]);
                      
                      p.push(null); // start new segment
                      p.push(null);
                      for (m = 2; m < ps; ++m)
                          p.push(origpoints[i + m]);
                      p.push(interx);
                      p.push(below);
                      for (m = 2; m < ps; ++m)
                          p.push(origpoints[i + m]);
                  }
  
                  p.push(x);
                  p.push(y);
                  for (m = 2; m < ps; ++m)
                      p.push(origpoints[i + m]);
              }
  
              datapoints.points = newpoints;
              thresholded.datapoints.points = threspoints;
              
              if (thresholded.datapoints.points.length > 0) {
                  var origIndex = $.inArray(s, plot.getData());
                  // Insert newly-generated series right after original one (to prevent it from becoming top-most)
                  plot.getData().splice(origIndex + 1, 0, thresholded);
              }
                  
              // FIXME: there are probably some edge cases left in bars
          }
          
          function processThresholds(plot, s, datapoints) {
              if (!s.threshold)
                  return;
              
              if (s.threshold instanceof Array) {
                  s.threshold.sort(function(a, b) {
                      return a.below - b.below;
                  });
                  
                  $(s.threshold).each(function(i, th) {
                      thresholdData(plot, s, datapoints, th.below, th.color);
                  });
              }
              else {
                  thresholdData(plot, s, datapoints, s.threshold.below, s.threshold.color);
              }
          }
          
          plot.hooks.processDatapoints.push(processThresholds);
      }
      
      $.plot.plugins.push({
          init: init,
          options: options,
          name: 'threshold',
          version: '1.2'
      });
  })(jQuery);