Merge pull request #19 from mbaak/1.0.x

This is great! The Categorize type is underused in our HEP users' work, so I'm glad it's getting covered.

Thanks!

Author: jpivarski

histogrammar/plot/bokeh.py

@@ -116,6 +116,10 @@ def plotbokeh(self,glyphType="line",glyphSize=1,fillColor="red",lineColor="black
         return GlyphRenderer(glyph=glyph,data_source=source)
 
 
+class CategorizeHistogramMethods(object):
+    pass
+
+
 class ProfileMethods(object):
     def plotbokeh(self,glyphType="line",glyphSize=1,fillColor="red",lineColor="black",lineAlpha=1,fillAlpha=0.1,lineDash='solid'):
 

histogrammar/plot/matplotlib.py

@@ -180,7 +180,71 @@ def bin_centers(self):
         centers = [(bin_edges[i]+bin_edges[i+1])/2. for i in range(len(bin_edges)-1)]
         return np.array(centers)
 
-    
+
+class CategorizeHistogramMethods(object):
+    def plotmatplotlib(self, name=None, **kwargs):
+        """
+            name : title of the plot.
+            kwargs :  `matplotlib.patches.Rectangle` properties.
+
+            Returns a matplotlib.axes instance
+        """
+        import matplotlib.pyplot as plt
+        import numpy as np
+        ax = plt.gca()
+
+        width = kwargs.pop('width',0.8)
+
+        labels = self.bin_labels()
+        values = self.bin_entries()
+        assert len(labels)==len(values), \
+            'labels and values have different array lengths: %d vs %d.' % \
+            (len(labels),len(values))
+
+        # plot histogram
+        tick_pos = np.arange(len(labels)) + 0.5
+        ax.bar(tick_pos - 0.4, values, width=width, **kwargs)
+
+        # set x-axis properties
+        def xtick(lab):
+            lab = str(lab)
+            if len(lab) > 20:
+                lab = lab[:17] + '...'
+            return lab
+        ax.set_xlim((0., float(len(labels))))
+        ax.set_xticks(tick_pos)
+        ax.set_xticklabels([xtick(lab) for lab in labels], fontsize=12, rotation=90)
+
+        # set title
+        if name is not None:
+            ax.set_title(name)
+        else:
+            ax.set_title(self.name)
+
+        return ax
+
+    def bin_entries(self):
+        """
+        Returns bin values
+        """
+        import numpy as np
+        return np.array([self.bins[i].entries for i in self.bins])
+
+    def bin_labels(self):
+        """
+        Returns bin labels
+        """
+        import numpy as np
+        labels = []
+        for i,key in enumerate(self.bins.keys()):
+            try:
+                label = str(key)
+            except:
+                label = 'bin_%d' % i
+            labels.append(label)
+        return np.asarray(labels)
+
+
 class ProfileMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
         """ Plotting method for Bin of Average
@@ -418,10 +482,10 @@ def plotmatplotlib(self, name=None, **kwargs):
         ax = plt.gca()
 
         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)
+        ax.set_ylim(self.y_lim())
+        ax.set_xlim(self.x_lim())
 
         if name is not None:
             ax.set_title(name)
@@ -456,7 +520,39 @@ def y_lim(self):
         """
         samp = self.values[0]
         return (samp.low,samp.high)
+
+    def project_on_x(self):
+        """ project 2d histogram onto x-axis
+
+        :returns: on x-axis projected histogram (1d)
+        :rtype: histogrammar.Bin
+        """
+        from histogrammar import Bin, Count
+
+        h_x = Bin(num = self.num, low = self.low, high = self.high, \
+                  quantity = self.quantity, value = Count())
+        # loop over all counters and integrate over y (=j)
+        for i,bi in enumerate(self.values):
+            h_x.values[i].entries += sum(bj.entries for bj in bi.values) 
+        return h_x
+
+    def project_on_y(self):
+        """ project 2d histogram onto y-axis
+
+        :returns: on y-axis projected histogram (1d)
+        :rtype: histogrammar.Bin
+        """
+        from histogrammar import Bin, Count
 
+        ybin = self.values[0]
+        h_y = Bin(num = ybin.num, low = ybin.low, high = ybin.high, \
+                  quantity = ybin.quantity, value = Count())
+        # loop over all counters and integrate over x (=i)
+        for bi in self.values:
+            for j,bj in enumerate(bi.values):
+                h_y.values[j].entries += bj.entries
+        return h_y
+    
 
 class SparselyTwoDimensionallyHistogramMethods(object):
     def plotmatplotlib(self, name=None, **kwargs):
@@ -491,7 +587,11 @@ def xy_ranges_grid(self):
         yminBin, ymaxBin, ynum, ylow, yhigh = prepare2Dsparse(self)
 
         xbinWidth = self.binWidth
-        ybinWidth = self.bins[0].binWidth
+        try:
+            ykey = list(self.bins.keys())[0]
+        except:
+            raise KeyError('SparselyBin 2d hist is not filled.')
+        ybinWidth = self.bins[ykey].binWidth
 
         xmaxBin = max(self.bins.keys())
         xminBin = min(self.bins.keys())
@@ -521,3 +621,42 @@ def y_lim(self):
         yminBin, ymaxBin, ynum, ylow, yhigh = prepare2Dsparse(self)
         return (ylow,yhigh)
 
+    def project_on_x(self):
+        """ project 2d sparselybin histogram onto x-axis
+
+        :returns: on x-axis projected histogram (1d)
+        :rtype: histogrammar.SparselyBin
+        """
+        from histogrammar import SparselyBin, Count
+
+        h_x = SparselyBin(binWidth = self.binWidth, origin = self.origin, \
+                          quantity = self.quantity, value = Count())
+        # loop over all counters and integrate over y (=j)
+        for i in self.bins:
+            bi = self.bins[i]
+            h_x.bins[i] = Count.ed( sum(bi.bins[j].entries for j in bi.bins) ) 
+        return h_x
+
+    def project_on_y(self):
+        """ project 2d sparselybin histogram onto y-axis
+
+        :returns: on y-axis projected histogram (1d)
+        :rtype: histogrammar.SparselyBin
+        """
+        from histogrammar import SparselyBin, Count
+
+        try:
+            ykey = list(self.bins.keys())[0]
+        except:
+            raise KeyError('SparselyBin 2d hist is not filled. Cannot project on y-axis.')
+        ybin = self.bins[ykey]
+        h_y = SparselyBin(binWidth = ybin.binWidth, origin = ybin.origin, \
+                          quantity = ybin.quantity, value = Count())
+        # loop over all counters and integrate over x (=i)
+        for i in self.bins:
+            bi = self.bins[i]
+            for j in bi.bins:
+                if not j in h_y.bins:
+                    h_y.bins[j] = Count()
+                h_y.bins[j].entries += bi.bins[j].entries
+        return h_y

histogrammar/plot/root.py

@@ -89,6 +89,28 @@ def plotroot(self, name, title="", binType="D"):
             setTH1(self.entries, [self.bins[i].entries if i in self.bins else 0.0 for i in xrange(self.minBin, self.maxBin + 1)], 0.0, 0.0, th1)
         return th1
 
+class CategorizeHistogramMethods(object):
+    def plotroot(self, name, title="", binType="C"):
+        """ Construct a ROOT histogram
+            
+        :param str name: name of the histogram 
+        :param str title: title of the histogram (optional)
+        :param str binType: histogram bin type. Default is "C" (char).
+        :returns: ROOT histgram
+        """
+        import ROOT
+        constructor = getattr(ROOT, "TH1" + binType)
+        th1 = constructor(name, title, len(self.bins), 0, 1)
+        th1.SetMinimum(0)
+        for i,key in enumerate(self.bins.keys()):
+            b = self.bins[key]
+            try:
+                label = str(key)
+            except:
+                label = 'bin_%d' % i
+            th1.Fill(label,b.entries)
+        return th1
+
 class ProfileMethods(object):
     def plotroot(self, name, title=""):
         import ROOT

histogrammar/primitives/categorize.py

@@ -80,7 +80,7 @@ def __init__(self, quantity, value=Count()):
         self.value = value
         self.bins = {}
         if value is not None:
-            self.contentType = str(value.factory.name)
+            self.contentType = value.name
         super(Categorize, self).__init__()
         self.specialize()
 

histogrammar/specialized.py

@@ -23,6 +23,7 @@
 from histogrammar.primitives.irregularlybin import IrregularlyBin
 from histogrammar.primitives.select import Select
 from histogrammar.primitives.sparselybin import SparselyBin
+from histogrammar.primitives.categorize import Categorize
 from histogrammar.primitives.stack import Stack
 from histogrammar.util import serializable
 
@@ -36,10 +37,14 @@ def Histogram(num, low, high, quantity, selection=unweighted):
         Count.ing(), Count.ing(), Count.ing(), Count.ing()))
 
 def SparselyHistogram(binWidth, quantity, selection=unweighted, origin=0.0):
-    "Convenience function for creating a sparsely binned histogram."
+    """Convenience function for creating a sparsely binned histogram."""
     return Select.ing(selection,
         SparselyBin.ing(binWidth, quantity, Count.ing(), Count.ing(), origin))
 
+def CategorizeHistogram(quantity, selection=unweighted):
+    """Convenience function for creating a categorize histogram."""
+    return Select.ing(selection, Categorize.ing(quantity, Count.ing()))
+
 def Profile(num, low, high, binnedQuantity, averagedQuantity, selection=unweighted):
     """Convenience function for creating binwise averages."""
     return Select.ing(selection,
@@ -139,6 +144,21 @@ def confidenceIntervalValues(self,absz=1.0):
         from math import sqrt
         return map(lambda v: absz*sqrt(v), [v.entries for _, v in sorted(self.bins.items())])
 
+class CategorizeHistogramMethods(Categorize,
+                                 histogrammar.plot.root.CategorizeHistogramMethods,
+                                 histogrammar.plot.bokeh.CategorizeHistogramMethods,
+                                 histogrammar.plot.matplotlib.CategorizeHistogramMethods):
+
+    """Methods that are implicitly added to container combinations that look like categorical histograms."""
+
+    @property
+    def name(self):
+        return "Categorize"
+
+    @property
+    def factory(self):
+        return Categorize
+
 class ProfileMethods(Bin,
         histogrammar.plot.root.ProfileMethods,
         histogrammar.plot.bokeh.ProfileMethods,
@@ -326,6 +346,9 @@ def addImplicitMethods(container):
     elif isinstance(container, SparselyBin) and container.contentType == "Count" and all(isinstance(v, Count) for v in container.bins.values()):
         container.__class__ = SparselyHistogramMethods
 
+    elif isinstance(container, Categorize) and container.contentType == "Count" and all(isinstance(v, Count) for v in container.bins.values()):
+        container.__class__ = CategorizeHistogramMethods
+
     elif isinstance(container, Bin) and all(isinstance(v, Average) for v in container.values):
         container.__class__ = ProfileMethods