Added plotting methods for Categorize type histograms

To make plotting work for Categorize histograms, I had to add a CategorizeHistogram
class to the file specialize.py, to add addImplicitMethods() to Categorize histograms,
in order to ensure that the plotting functions are recognized in python.
Similarly, in primitives/categorize.py I had to properly set the contentType of a Categorize object.
(I copied the example of SparselyHistogram where required.)

I only added matplotlib and ROOT plotting functions for Categorize histograms,
as I'm not very familiar with bokey.
The bokey plotting class for Categorize histograms is currently a dummy class.

Author: Max Baak

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

@@ -179,6 +179,70 @@ def bin_centers(self):
         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 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):

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