Merge pull request #18 from mbaak/master

All checks passed, so I'm approving it. Will need to back-port from master to 1.0.x, though.

Author: jpivarski

histogrammar/plot/bokeh.py

@@ -19,6 +19,9 @@
 
 import math
 
+# python 2/3 compatibility fixes
+from histogrammar.util import *
+
 class HistogramMethods(object):
     def plotbokeh(self,glyphType="line",glyphSize=1,fillColor="red",lineColor="black",lineAlpha=1,fillAlpha=0.1,lineDash='solid'):
 

histogrammar/plot/matplotlib.py

@@ -17,6 +17,8 @@
 from __future__ import absolute_import
 import types
 
+# python 2/3 compatibility fixes
+from histogrammar.util import *
 
 def prepare2Dsparse(sparse):
     yminBins = [v.minBin for v in sparse.bins.values() if v.minBin is not None]
@@ -25,10 +27,10 @@ def prepare2Dsparse(sparse):
         yminBin = min(yminBins)
         ymaxBin = max(ymaxBins)
     else:
-        yminBin = 0.0
-        ymaxBin = 0.0
+        yminBin = 0
+        ymaxBin = 0
     sample = list(sparse.bins.values())[0]
-    ynum = 1.0 + ymaxBin - yminBin
+    ynum = 1 + ymaxBin - yminBin
     ylow = yminBin * sample.binWidth + sample.origin
     yhigh = (ymaxBin + 1.0) * sample.binWidth + sample.origin
     return yminBin, ymaxBin, ynum, ylow, yhigh
@@ -52,13 +54,11 @@ def plotmatplotlib(self, name=None, **kwargs):
         import numpy as np
         ax = plt.gca()
 
-        entries = [x.entries for x in self.values]
+        edges = self.bin_edges()
+        entries = self.bin_entries()
+        width = self.bin_width()
 
-        num_bins = len(self.values)
-        width = (self.high - self.low)/num_bins
-        edges = np.linspace(self.low, self.high, num_bins + 1)[:-1]
-
-        ax.bar(edges, entries, width=width, **kwargs)
+        ax.bar(edges[:-1], entries, width=width, **kwargs)
 
         if name is not None:
             ax.set_title(name)
@@ -67,6 +67,42 @@ def plotmatplotlib(self, name=None, **kwargs):
 
         return ax
 
+    def num_bins(self):
+        """
+        Returns number of bins
+        """
+        return len(self.values)
+    
+    def bin_width(self):
+        """
+        Returns bin width
+        """
+        return (self.high - self.low) / self.num_bins()
+    
+    def bin_entries(self):
+        """
+        Returns bin values
+        """
+        import numpy as np
+        return np.array([x.entries for x in self.values])
+
+    def bin_edges(self):
+        """
+        Returns bin edges
+        """
+        import numpy as np
+        num_bins = self.num_bins()
+        edges = np.linspace(self.low, self.high, num_bins + 1)
+        return edges
+
+    def bin_centers(self):
+        """
+        Returns bin centers
+        """
+        import numpy as np
+        return np.array([sum(self.range(i))/2.0 for i in self.indexes])
+
+
 class SparselyHistogramMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
         """
@@ -79,21 +115,72 @@ def plotmatplotlib(self, name=None, **kwargs):
         import numpy as np
         ax = plt.gca()
 
-        if self.minBin is None or self.maxBin is None:
-            ax.bar([self.origin, self.origin + 1], self.bins[0].entries, width=self.binWidth, **kwargs)
-        else:
-            size = 1 + self.maxBin - self.minBin
-            entries = [self.bins[i].entries if i in self.bins else 0.0 for i in xrange(self.minBin, self.maxBin + 1)]
-            edges = np.linspace(self.minBin, self.maxBin, len(entries) + 1)[:-1]
-            ax.bar(edges, entries, width=self.binWidth, **kwargs)
+        edges = self.bin_edges()
+        entries = self.bin_entries()
+        width = self.bin_width()
 
+        ax.bar(edges[:-1], entries, width=width, **kwargs)
+        ax.set_xlim(self.low,self.high)
+        
         if name is not None:
             ax.set_title(name)
         else:
             ax.set_title(self.name)
 
         return ax
 
+    def num_bins(self):
+        """
+        Returns number of bins
+        """
+        if self.minBin is None or self.maxBin is None:
+            return 0
+        nbins = self.maxBin - self.minBin + 1
+        return nbins
+    
+    def bin_width(self):
+        """
+        Returns bin width
+        """
+        return self.binWidth
+
+    def bin_edges(self):
+        """
+        Returns bin_edges
+        """
+        import numpy as np
+
+        if self.minBin is None or self.maxBin is None:
+            edges = np.array([self.origin, self.origin + 1])
+        else:
+            num_bins = self.maxBin - self.minBin + 1
+            edges = np.linspace(self.low, self.high, num_bins + 1)
+        return edges
+    
+    def bin_entries(self):
+        """
+        Returns bin values
+        """
+        import numpy as np
+
+        if self.minBin is None or self.maxBin is None:
+            entries = [self.bins[0].entries]
+        else:
+            entries = [self.bins[i].entries if i in self.bins else 0.0 \
+                       for i in range(self.minBin, self.maxBin + 1)]
+        return np.array(entries)
+
+    def bin_centers(self):
+        """
+        Returns bin centers
+        """
+        import numpy as np
+
+        bin_edges = self.bin_edges()
+        centers = [(bin_edges[i]+bin_edges[i+1])/2. for i in range(len(bin_edges)-1)]
+        return np.array(centers)
+        
+    
 class ProfileMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
         """ Plotting method for Bin of Average
@@ -242,7 +329,7 @@ def plotmatplotlib(self, name=None, **kwargs):
         import numpy as np
         ax = plt.gca()
         color_cycle = plt.rcParams['axes.color_cycle']
-        if kwargs.has_key("color"):
+        if "color" in kwargs:
             kwargs.pop("color")
 
         for i, hist in enumerate(self.values):
@@ -264,7 +351,7 @@ def plotmatplotlib(self, name=None, **kwargs):
         import numpy as np
         ax = plt.gca()
         color_cycle = plt.rcParams['axes.color_cycle']
-        if kwargs.has_key("color"):
+        if "color" in kwargs:
             kwargs.pop("color")
 
         for i, hist in enumerate(self.values):
@@ -330,15 +417,9 @@ def plotmatplotlib(self, name=None, **kwargs):
         import numpy as np
         ax = plt.gca()
 
-        samp = self.values[0]
-        x_ranges = np.unique(np.array([self.range(i) for i in self.indexes]).flatten())
-        y_ranges = np.unique(np.array([samp.range(i) for i in samp.indexes]).flatten())
-
-        grid = np.zeros((samp.num, self.num))
-
-        for j in xrange(self.num):
-            for i in xrange(samp.num):
-                grid[i,j] = self.values[j].values[i].entries
+        x_ranges, y_ranges, grid = self.xy_ranges_grid()
+        ax.set_ylim(self.y_lim())
+        ax.set_xlim(self.x_lim())
 
         ax.pcolormesh(x_ranges, y_ranges, grid, **kwargs)
 
@@ -348,6 +429,34 @@ def plotmatplotlib(self, name=None, **kwargs):
             ax.set_title(self.name)
         return ax
 
+    def xy_ranges_grid(self):
+        """ Return x and y ranges and x,y grid
+        """
+        import numpy as np
+
+        samp = self.values[0]
+        x_ranges = np.unique(np.array([self.range(i) for i in self.indexes]).flatten())
+        y_ranges = np.unique(np.array([samp.range(i) for i in samp.indexes]).flatten())
+
+        grid = np.zeros((samp.num, self.num))
+
+        for j in range(self.num):
+            for i in range(samp.num):
+                grid[i,j] = self.values[j].values[i].entries
+
+        return x_ranges, y_ranges, grid
+
+    def x_lim(self):
+        """ return x low high tuble
+        """
+        return (self.low,self.high)
+    
+    def y_lim(self):
+        """ return y low high tuble
+        """
+        samp = self.values[0]
+        return (samp.low,samp.high)
+        
 
 class SparselyTwoDimensionallyHistogramMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
@@ -361,6 +470,24 @@ def plotmatplotlib(self, name=None, **kwargs):
         import numpy as np
         ax = plt.gca()
 
+        x_ranges, y_ranges, grid = self.xy_ranges_grid()
+        
+        ax.pcolormesh(x_ranges, y_ranges, grid, **kwargs)
+        ax.set_ylim(self.y_lim())
+        ax.set_xlim(self.x_lim())
+
+        if name is not None:
+            ax.set_title(name)
+        else:
+            ax.set_title(self.name)
+
+        return ax
+
+    def xy_ranges_grid(self):
+        """ Return x and y ranges and x,y grid
+        """
+        import numpy as np
+
         yminBin, ymaxBin, ynum, ylow, yhigh = prepare2Dsparse(self)
 
         xbinWidth = self.binWidth
@@ -377,17 +504,20 @@ def plotmatplotlib(self, name=None, **kwargs):
         x_ranges = np.arange(xlow, xhigh + xbinWidth, xbinWidth)
         y_ranges = np.arange(ylow, yhigh + ybinWidth, ybinWidth)
 
-        ax.pcolormesh(x_ranges, y_ranges, grid, **kwargs)
-        ax.set_ylim((ylow, yhigh))
-        ax.set_xlim((xlow, xhigh))
-
-        if name is not None:
-            ax.set_title(name)
-        else:
-            ax.set_title(self.name)
-
-        return ax
-
-
-
+        return x_ranges, y_ranges, grid
 
+    def x_lim(self):
+        """ return x low high tuble
+        """
+        xmaxBin = max(self.bins.keys())
+        xminBin = min(self.bins.keys())
+        xlow = xminBin * self.binWidth + self.origin
+        xhigh = (xmaxBin + 1) * self.binWidth + self.origin
+        return (xlow,xhigh)
+    
+    def y_lim(self):
+        """ return y low high tuble
+        """
+        yminBin, ymaxBin, ynum, ylow, yhigh = prepare2Dsparse(self)
+        return (ylow,yhigh)
+        

histogrammar/plot/root.py

@@ -19,6 +19,9 @@
 import math
 import types
 
+# python 2/3 compatibility fixes
+from histogrammar.util import *
+
 try:
     from collections import OrderedDict
 except ImportError:
@@ -229,7 +232,8 @@ def plotroot(self, name, title="", binType="D"):
         import ROOT
         constructor = getattr(ROOT, "TH2" + binType)
         sample = self.values[0]
-        th2 = constructor(name, title, self.num, self.low, self.high, sample.num, sample.low, sample.high)
+        th2 = constructor(name, title, int(self.num), float(self.low), float(self.high), \
+                          int(sample.num), float(sample.low), float(sample.high))
         for i in xrange(self.num):
             for j in xrange(sample.num):
                 th2.SetBinContent(i + 1, j + 1, self.values[i].values[j].entries)
@@ -240,6 +244,7 @@ def plotroot(self, name, title="", binType="D"):
         import ROOT
         constructor = getattr(ROOT, "TH2" + binType)
         yminBin, ymaxBin, ynum, ylow, yhigh = prepareTH2sparse(self)
-        th2 = constructor(name, title, self.num, self.low, self.high, ynum, ylow, yhigh)
+        th2 = constructor(name, title, int(self.num), float(self.low), float(self.high), \
+                          int(ynum), float(ylow), float(yhigh))
         setTH2sparse(self, yminBin, ymaxBin, th2)
         return th2

histogrammar/primitives/sparselybin.py

@@ -222,7 +222,7 @@ def high(self):
         else:
             return (self.maxBin + 1) * self.binWidth + self.origin
 
-    def at(index):
+    def at(self, index):
         """Extract the container at a given index, if it exists."""
         return self.bins.get(index, None)
 
@@ -231,7 +231,7 @@ def indexes(self):
         """Get a sequence of filled indexes."""
         return sorted(self.keys)
 
-    def range(index):
+    def range(self, index):
         """Get the low and high edge of a bin (given by index number)."""
         return (index * self.binWidth + self.origin, (index + 1) * self.binWidth + self.origin)