Merge pull request yhat#325 from arnfred/bar

Reworked bar plot

Author: glamp

ggplot/geoms/geom.py

@@ -3,7 +3,9 @@
 from copy import deepcopy
 
 import pandas as pd
+import numpy as np
 from matplotlib.cbook import iterable
+from ggplot.utils import is_string
 
 import ggplot.stats
 from ggplot.utils import is_scalar_or_string
@@ -199,7 +201,7 @@ def _find_aes_and_data(self, args, kwargs):
 
         for arg in args:
             if isinstance(arg, aes) and passed_aes:
-                raise Execption(aes_err)
+                raise Exception(aes_err)
             if isinstance(arg, aes):
                 passed_aes = arg
             elif isinstance(arg, pd.DataFrame):
@@ -255,6 +257,7 @@ def _calculate_stats(self, data):
         data : dataframe
         """
         self._stat._verify_aesthetics(data)
+        self._stat._calculate_global(data)
         # In most cases 'x' and 'y' mappings do not and
         # should not influence the grouping. If this is
         # not the desired behaviour then the groups
@@ -274,9 +277,6 @@ def _calculate_stats(self, data):
         else:
             new_data = self._stat._calculate(data)
 
-        # some geoms expect a sorted x domain
-        if 'x' in new_data:
-            new_data.sort(columns=('x'), inplace=True)
         return new_data
 
     def _create_aes_with_mpl_names(self):
@@ -338,3 +338,33 @@ def _get_unit_grouped_data(self, data, units):
             _data = data.to_dict('list')
             out.append(_data)
         return out
+
+
+    def sort_by_x(self, pinfo):
+        """
+        Sort the lists in pinfo according to pinfo['x']
+        This function is useful for geom's that expect
+        the x-values to come in sorted order
+        """
+        # Remove list types from pinfo
+        _d = {}
+        for k in list(pinfo.keys()):
+            if not is_string(pinfo[k]) and iterable(pinfo[k]):
+                _d[k] = pinfo.pop(k)
+
+        # Sort numerically if all items can be cast
+        try:
+            x = list(map(np.float, _d['x']))
+        except (ValueError, TypeError):
+            x = _d['x']
+
+        # Make sure we don't try to sort something unsortable
+        try:
+            idx = np.argsort(x)
+            # Put sorted lists back in pinfo
+            for key in _d:
+                pinfo[key] = [_d[key][i] for i in idx]
+        except:
+            pass
+        return pinfo
+

ggplot/geoms/geom_area.py

@@ -1,5 +1,6 @@
 from __future__ import (absolute_import, division, print_function,
                         unicode_literals)
+
 from .geom import geom
 
 
@@ -14,4 +15,5 @@ class geom_area(geom):
     _units = { 'alpha', 'edgecolor', 'facecolor', 'linestyle', 'linewidth'}
 
     def _plot_unit(self, pinfo, ax):
+        pinfo = self.sort_by_x(pinfo)
         ax.fill_between(**pinfo)

ggplot/geoms/geom_bar.py

@@ -11,7 +11,7 @@
 
 class geom_bar(geom):
     DEFAULT_AES = {'alpha': None, 'color': None, 'fill': '#333333',
-                   'linetype': 'solid', 'size': 1.0, 'weight': None, 'y': None}
+                   'linetype': 'solid', 'size': 1.0, 'weight': None, 'y': None, 'width' : None}
     REQUIRED_AES = {'x'}
     DEFAULT_PARAMS = {'stat': 'bin', 'position': 'stack'}
 
@@ -20,43 +20,35 @@ class geom_bar(geom):
                     'fill': 'color', 'color': 'edgecolor'}
     # NOTE: Currently, geom_bar does not support mapping
     # to alpha and linestyle. TODO: raise exception
-    _units = {'alpha', 'linestyle', 'linewidth'}
+    _units = {'edgecolor', 'color', 'alpha', 'linestyle', 'linewidth'}
 
-    def _sort_list_types_by_x(self, pinfo):
-        """
-        Sort the lists in pinfo according to pinfo['x']
-        """
-        # Remove list types from pinfo
-        _d = {}
-        for k in list(pinfo.keys()):
-            if not is_string(pinfo[k]) and cbook.iterable(pinfo[k]):
-                _d[k] = pinfo.pop(k)
 
-        # Sort numerically if all items can be cast
-        try:
-            x = list(map(np.float, _d['x']))
-        except ValueError:
-            x = _d['x']
-        idx = np.argsort(x)
+    def __init__(self, *args, **kwargs):
+        # TODO: Change self.__class__ to geom_bar
+        super(geom_bar, self).__init__(*args, **kwargs)
+        self.bottom = None
+        self.ax = None
 
-        # Put sorted lists back in pinfo
-        for key in _d:
-            pinfo[key] = [_d[key][i] for i in idx]
-
-        return pinfo
 
     def _plot_unit(self, pinfo, ax):
         categorical = is_categorical(pinfo['x'])
-        # If x is not numeric, the bins are sorted acc. to x
-        # so the list type aesthetics must be sorted too
-        if categorical:
-            pinfo = self._sort_list_types_by_x(pinfo)
 
         pinfo.pop('weight')
         x = pinfo.pop('x')
-        width = np.array(pinfo.pop('width'))
-        heights = pinfo.pop('y')
-        labels = x
+        width_elem = pinfo.pop('width')
+        # If width is unspecified, default is an array of 1's
+        if width_elem == None:
+            width = np.ones(len(x))
+        else :
+            width = np.array(width_elem)
+
+        # Make sure bottom is initialized and get heights. If we are working on
+        # a new plot (using facet_wrap or grid), then reset bottom
+        _reset = self.bottom == None or (self.ax != None and self.ax != ax)
+        self.bottom = np.zeros(len(x)) if _reset else self.bottom
+        self.ax = ax
+        heights = np.array(pinfo.pop('y'))
+
 
         # layout and spacing
         #
@@ -79,14 +71,14 @@ def _plot_unit(self, pinfo, ax):
             _spacing_factor = 0.105     # of the bin width
             _breaks = np.append([0], width)
             left = np.cumsum(_breaks[:-1])
-
         _sep = width[0] * _spacing_factor
         left = left + _left_gap + [_sep * i for i in range(len(left))]
-
-
-        ax.bar(left, heights, width, **pinfo)
+        ax.bar(left, heights, width, bottom=self.bottom, **pinfo)
         ax.autoscale()
 
         if categorical:
             ax.set_xticks(left+width/2)
             ax.set_xticklabels(x)
+
+        # Update bottom positions
+        self.bottom = heights + self.bottom

ggplot/geoms/geom_histogram.py

@@ -2,5 +2,4 @@
                         unicode_literals)
 from .geom_bar import geom_bar
 
-class geom_histogram(geom_bar):
-    pass
+geom_histogram = geom_bar

ggplot/geoms/geom_line.py

@@ -28,6 +28,7 @@ def _plot_unit(self, pinfo, ax):
                 sys.stderr.write(msg)
                 self._warning_printed = True
 
+        pinfo = self.sort_by_x(pinfo)
         x = pinfo.pop('x')
         y = pinfo.pop('y')
         ax.plot(x, y, **pinfo)

ggplot/stats/__init__.py

@@ -1,5 +1,5 @@
 from __future__ import (absolute_import, division, print_function,
-                        unicode_literals) 
+                        unicode_literals)
 
 from .stat_abline import stat_abline
 from .stat_bin import stat_bin
@@ -10,6 +10,7 @@
 from .stat_identity import stat_identity
 from .stat_smooth import stat_smooth
 from .stat_vline import stat_vline
+from .stat_bar import stat_bar
 
 __all__ = ['stat_abline', 'stat_bin', 'stat_bin2d', 'stat_density',
            'stat_function', 'stat_hline', 'stat_identity',

ggplot/stats/stat.py

@@ -46,6 +46,14 @@ def _print_warning(self, message):
             sys.stderr.write(message)
             self._warnings_printed.add(message)
 
+    # For some stats we need to calculate something from the entire set of data
+    # before we work with the groups. An example is stat_bin, where we need to
+    # know the max and min of the x-axis globally. If we don't we end up with
+    # groups that are binned based on only the group x-axis leading to
+    # different bin-sizes.
+    def _calculate_global(self, data):
+        pass
+
     def _calculate(self, data):
         msg = "{} should implement this method."
         raise NotImplementedError(

ggplot/stats/stat_bar.py

@@ -0,0 +1,39 @@
+from __future__ import (absolute_import, division, print_function,
+                        unicode_literals)
+import pandas as pd
+
+from .stat import stat
+
+_MSG_LABELS = """There are more than 30 unique values mapped to x.
+    If you want a histogram instead, use 'geom_histogram()'.
+"""
+
+class stat_bar(stat):
+    REQUIRED_AES = {'x', 'y'}
+    DEFAULT_PARAMS = {'geom': 'bar', 'position': 'stack',
+                      'width': 0.9, 'drop': False,
+                      'origin': None, 'labels': None}
+
+
+    def _calculate(self, data):
+        # reorder x according to the labels
+        new_data = pd.DataFrame()
+        new_data["x"] = self.labels
+        for column in set(data.columns) - set('x'):
+            column_dict = dict(zip(data["x"],data[column]))
+            default = 0 if column == "y" else data[column].values[0]
+            new_data[column] = [column_dict.get(val, default)
+                                for val in self.labels]
+        return new_data
+
+
+    def _calculate_global(self, data):
+        labels = self.params['labels']
+        if labels == None:
+            labels = sorted(set(data['x'].values))
+        # For a lot of labels, put out a warning
+        if len(labels) > 30:
+            self._print_warning(_MSG_LABELS)
+        # Check if there is a mapping
+        self.labels = labels
+

ggplot/stats/stat_bin.py

@@ -13,7 +13,7 @@
 _MSG_YVALUE = """A variable was mapped to y.
     stat_bin sets the y value to the count of cases in each group.
     The mapping to y was ignored.
-    If you want y to represent values in the data, use stat="identity".
+    If you want y to represent values in the data, use stat="bar".
 """
 
 _MSG_BINWIDTH = """stat_bin: binwidth defaulted to range/30.
@@ -23,16 +23,46 @@
 
 class stat_bin(stat):
     REQUIRED_AES = {'x'}
-    DEFAULT_PARAMS = {'geom': 'bar', 'position': 'stack',
+    DEFAULT_PARAMS = {'geom': 'histogram', 'position': 'stack',
                       'width': 0.9, 'drop': False, 'right': False,
-                      'binwidth': None, 'origin': None, 'breaks': None}
+                      'binwidth': None, 'origin': None, 'breaks': None,
+                      'labels': None}
     CREATES = {'y', 'width'}
 
+
+    def _calculate_global(self, data):
+        # Calculate breaks if x is not categorical
+        binwidth = self.params['binwidth']
+        self.breaks = self.params['breaks']
+        right = self.params['right']
+        x = data['x'].values
+
+        # For categorical data we set labels and x-vals
+        if is_categorical(x):
+            labels = self.params['labels']
+            if labels == None:
+                labels = sorted(set(x))
+            self.labels = labels
+            self.length = len(self.labels)
+
+        # For non-categoriacal data we set breaks
+        if not (is_categorical(x) or self.breaks):
+            # Check that x is numerical
+            if not cbook.is_numlike(x[0]):
+                raise GgplotError("Cannot recognise the type of x")
+            if binwidth is None:
+                _bin_count = 30
+                self._print_warning(_MSG_BINWIDTH)
+            else:
+                _bin_count = int(np.ceil(np.ptp(x))) / binwidth
+            _, self.breaks = pd.cut(x, bins=_bin_count, labels=False,
+                                        right=right, retbins=True)
+            self.length = len(self.breaks)
+
+
     def _calculate(self, data):
         x = data.pop('x')
-        breaks = self.params['breaks']
         right = self.params['right']
-        binwidth = self.params['binwidth']
 
         # y values are not needed
         try:
@@ -50,26 +80,16 @@ def _calculate(self, data):
         else:
             weights = make_iterable_ntimes(weights, len(x))
 
-        categorical = is_categorical(x.values)
-        if categorical:
+        if is_categorical(x.values):
             x_assignments = x
-            x = sorted(set(x))
-            width = make_iterable_ntimes(self.params['width'], len(x))
+            x = self.labels
+            width = make_iterable_ntimes(self.params['width'], self.length)
         elif cbook.is_numlike(x.iloc[0]):
-            if breaks is None and binwidth is None:
-                _bin_count = 30
-                self._print_warning(_MSG_BINWIDTH)
-            if binwidth:
-                _bin_count = int(np.ceil(np.ptp(x))) / binwidth
-
-            # Breaks have a higher precedence and,
-            # pandas accepts either the breaks or the number of bins
-            _bins_info = breaks or _bin_count
-            x_assignments, breaks = pd.cut(x, bins=_bins_info, labels=False,
-                                           right=right, retbins=True)
-            width = np.diff(breaks)
-            x = [breaks[i] + width[i] / 2
-                 for i in range(len(breaks)-1)]
+            x_assignments = pd.cut(x, bins=self.breaks, labels=False,
+                                           right=right)
+            width = np.diff(self.breaks)
+            x = [self.breaks[i] + width[i] / 2
+                 for i in range(len(self.breaks)-1)]
         else:
             raise GgplotError("Cannot recognise the type of x")
 
@@ -86,13 +106,14 @@ def _calculate(self, data):
         # For numerical x values, empty bins get have no value
         # in the computed frequency table. We need to add the zeros and
         # since frequency table is a Series object, we need to keep it ordered
-        if len(_wfreq_table) < len(x):
-            empty_bins = set(range(len(x))) - set(x_assignments)
-            _wfreq_table = _wfreq_table.to_dict()
-            for _b in empty_bins:
-                _wfreq_table[_b] = 0
-            _wfreq_table = pd.Series(_wfreq_table)
-            _wfreq_table = _wfreq_table.sort_index()
+        try:
+            empty_bins = set(self.labels) - set(x_assignments)
+        except:
+            empty_bins = set(range(len(width))) - set(x_assignments)
+        _wfreq_table = _wfreq_table.to_dict()
+        for _b in empty_bins:
+            _wfreq_table[_b] = 0
+        _wfreq_table = pd.Series(_wfreq_table).sort_index()
 
         y = list(_wfreq_table)
         new_data = pd.DataFrame({'x': x, 'y': y, 'width': width})

ggplot/tests/__init__.py

@@ -31,6 +31,7 @@ def teardown_package():
     'ggplot.tests.test_stat',
     'ggplot.tests.test_stat_calculate_methods',
     'ggplot.tests.test_geom_rect',
+    'ggplot.tests.test_geom_bar',
     'ggplot.tests.test_qplot',
     'ggplot.tests.test_geom_lines',
     'ggplot.tests.test_faceting',