scale_fill_*. other stuff too.

Author: glamp

README.rst

@@ -22,21 +22,6 @@ You can do cool things like this:
 .. figure:: ./docs/example.png
    :alt: 
 
-What happened to the old version that didn't work?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-It's gone--the windows, the doors,
-`everything <https://www.youtube.com/watch?v=YuxCKv_0GZc>`__. I deleted
-most of the code and only kept what worked. The data grouping and
-manipulation bits were re-written (so they actually worked) with things
-like facets in mind.
-
-Where did ``stat_identity`` and ``geom_raster`` go?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-They're gone. They didn't even come close to working (also what does
-``stat_identity`` even do) so they're gone.
-
 Installation
 ~~~~~~~~~~~~
 
@@ -54,3 +39,17 @@ Examples
 -  `gallery <./docs/Gallery.ipynb>`__
 -  `various examples <./examples.md>`__
 
+What happened to the old version that didn't work?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It's gone--the windows, the doors,
+`everything <https://www.youtube.com/watch?v=YuxCKv_0GZc>`__. I deleted
+most of the code and only kept what worked. The data grouping and
+manipulation bits were re-written (so they actually worked) with things
+like facets in mind.
+
+Where did ``stat_identity`` and ``geom_raster`` go?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+They're gone. They didn't even come close to working (also what does
+``stat_identity`` even do) so they're gone.

ggplot/__init__.py

@@ -39,6 +39,12 @@ def _set_mpl_backend():
 from .scales.scale_color_funfetti import scale_color_funfetti
 from .scales.scale_color_manual import scale_color_manual
 from .scales.scale_color_gradient import scale_color_gradient
+
+from .scales.scale_fill_brewer import scale_fill_brewer
+from .scales.scale_fill_crayon import scale_fill_crayon
+from .scales.scale_fill_funfetti import scale_fill_funfetti
+from .scales.scale_fill_manual import scale_fill_manual
+
 from .scales.scale_identity import scale_alpha_identity, scale_color_identity, scale_fill_identity, scale_linetype_identity, scale_shape_identity, scale_size_identity
 from .scales.scale_log import scale_x_log, scale_y_log
 from .scales.scale_reverse import scale_x_reverse, scale_y_reverse

ggplot/geoms/geom_bar.py

@@ -57,9 +57,6 @@ def plot(self, ax, data, _aes, x_levels, fill_levels, lookups):
 
         params = self._get_plot_args(data, _aes)
 
-        if self.params.get('position')=='fill':
-            pass
-
         if fill_levels is not None:
             width = .8 / len(fill_levels)
         else:

ggplot/ggplot.py

@@ -10,18 +10,15 @@
 import numpy as np
 import pandas as pd
 import warnings
-import itertools
 
 from .aes import aes
 from .legend import make_legend
 from .themes import theme_gray
 from . import discretemappers
 
-import pprint as pp
 from PIL import Image
 
 
-
 class ggplot(object):
     """
     ggplot is the base layer or object that you use to define
@@ -95,17 +92,20 @@ def __init__(self, aesthetics, data):
         self.colormap = None
         self.manual_color_list = []
 
+        # fill (pretty much t, colors=self.manual_fill_listhe same as colors)
+        self.manual_fill_list = []
+
         # coordinate system
         self.coords = None
 
 
     def __repr__(self):
         self.make()
         # this is nice for dev but not the best for "real"
-        # self.fig.savefig('/tmp/ggplot.png', dpi=160)
-        # img = Image.open('/tmp/ggplot.png')
-        # img.show()
-        plt.show()
+        self.fig.savefig('/tmp/ggplot.png', dpi=160)
+        img = Image.open('/tmp/ggplot.png')
+        img.show()
+        # plt.show()
         return "<ggplot: (%d)>" % self.__hash__()
 
     def _evaluate_aes_expressions(self):
@@ -290,7 +290,7 @@ def _get_mapping(self, aes_type, colname):
         if aes_type=="color":
             mapping = discretemappers.color_gen(self.data[colname].nunique(), colors=self.manual_color_list)
         elif aes_type=="fill":
-            mapping = discretemappers.color_gen(self.data[colname].nunique())
+            mapping = discretemappers.color_gen(self.data[colname].nunique(), colors=self.manual_fill_list)
         elif aes_type=="shape":
             mapping = discretemappers.shape_gen()
         elif aes_type=="linetype":

ggplot/legend.py

@@ -30,7 +30,6 @@ def color_legend(color):
     # TODO: need outline on line
     return plt.Line2D([0],[0], color=color, linewidth=5)
 
-# TODO(bug): this *sometimes* decides to not use marker='o'
 def size_legend(size):
     return plt.Line2D([0],[0], color='black', marker='o', linestyle='None', markersize=size**.5)
 
@@ -43,98 +42,45 @@ def shape_legend(shape):
 def linetype_legend(linetype):
     return plt.Line2D([0],[0], color='black', linestyle=linetype)
 
+def make_aesthetic_legend(aesthetic, value):
+    if aesthetic=='color':
+        return color_legend(value)
+    elif aesthetic=='fill':
+        return color_legend(value)
+    elif aesthetic=='size':
+        return size_legend(value)
+    elif aesthetic=='alpha':
+        return alpha_legend(value)
+    elif aesthetic=='shape':
+        return shape_legend(value)
+    elif aesthetic=='linetype':
+        return linetype_legend(value)
+    else:
+        print(aesthetic + " not found")
 
 def make_legend(ax, legend_mapping):
     # TODO: for some reason this reaks havoc! but this is also how you would do a bold legend :(
     # plt.rc('text', usetex=True)
-
+    
     extra = Rectangle((0, 0), 0, 0, facecolor="w", fill=False, edgecolor='none', linewidth=0)
 
     items = []
     labels = []
 
-    if 'color' in legend_mapping:
-        items.append(extra)
-        colname = legend_mapping['color']['name']
-        # spacer = r'\n' if len(labels) > 0 else r''
-        spacer = '\n' if len(labels) > 0 else ''
-        # TODO: this is supposed to make the label bold
-        # labels.append(spacer + r'\textbf{' + colname + '}')
-        labels.append(spacer + colname)
-        for key in sorted(legend_mapping['color']['lookup'].keys()):
-            value = legend_mapping['color']['lookup'][key]
-            legend_item = color_legend(value)
-            items.append(legend_item)
-            labels.append(key)
-
-    if 'fill' in legend_mapping:
-        items.append(extra)
-        colname = legend_mapping['fill']['name']
-        # spacer = r'\n' if len(labels) > 0 else r''
-        spacer = '\n' if len(labels) > 0 else ''
-        # TODO: this is supposed to make the label bold
-        # labels.append(spacer + r'\textbf{' + colname + '}')
-        labels.append(spacer + colname)
-        for key in sorted(legend_mapping['fill']['lookup'].keys()):
-            value = legend_mapping['fill']['lookup'][key]
-            legend_item = color_legend(value)
-            items.append(legend_item)
-            labels.append(key)
-
-    if 'shape' in legend_mapping:
-        items.append(extra)
-        colname = legend_mapping['shape']['name']
-        # spacer = r'\n' if len(labels) > 0 else r''
-        spacer = '\n' if len(labels) > 0 else ''
-        # TODO: this is supposed to make the label bold
-        # labels.append(spacer + r'\textbf{' + colname + '}')
-        labels.append(spacer + colname)
-        for key in sorted(legend_mapping['shape']['lookup'].keys()):
-            value = legend_mapping['shape']['lookup'][key]
-            legend_item = shape_legend(value)
-            items.append(legend_item)
-            labels.append(key)
-
-    if 'alpha' in legend_mapping:
-        items.append(extra)
-        colname = legend_mapping['alpha']['name']
-        # spacer = r'\n' if len(labels) > 0 else r''
-        spacer = '\n' if len(labels) > 0 else ''
-        # TODO: this is supposed to make the label bold
-        # labels.append(spacer + r'\textbf{' + colname + '}')
-        labels.append(spacer + colname)
-        for key in sorted(legend_mapping['alpha']['lookup'].keys()):
-            value = legend_mapping['alpha']['lookup'][key]
-            legend_item = alpha_legend(value)
-            items.append(legend_item)
-            labels.append(key)
-
-    if 'size' in legend_mapping:
-        items.append(extra)
-        colname = legend_mapping['size']['name']
-        # spacer = r'\n' if len(labels) > 0 else r''
-        spacer = '\n' if len(labels) > 0 else ''
-        # TODO: this is supposed to make the label bold
-        # labels.append(spacer + r'\textbf{' + colname + '}')
-        labels.append(spacer + colname)
-        for key in sorted(legend_mapping['size']['lookup'].keys()):
-            value = legend_mapping['size']['lookup'][key]
-            legend_item = size_legend(value)
-            items.append(legend_item)
-            labels.append(key)
-
-    if 'linetype' in legend_mapping:
-        items.append(extra)
-        colname = legend_mapping['linetype']['name']
-        # spacer = r'\n' if len(labels) > 0 else r''
-        spacer = '\n' if len(labels) > 0 else ''
-        # TODO: this is supposed to make the label bold
-        # labels.append(spacer + r'\textbf{' + colname + '}')
-        labels.append(spacer + colname)
-        for key in sorted(legend_mapping['linetype']['lookup'].keys()):
-            value = legend_mapping['linetype']['lookup'][key]
-            legend_item = linetype_legend(value)
-            items.append(legend_item)
-            labels.append(key)
+    for aesthetic in ['color', 'fill', 'shape', 'alpha', 'size', 'linetype']:
+
+        if aesthetic in legend_mapping:
+            items.append(extra)
+            colname = legend_mapping[aesthetic]['name']
+            # spacer = r'\n' if len(labels) > 0 else r''
+            spacer = '\n' if len(labels) > 0 else ''
+            # TODO: this is supposed to make the label bold
+            # labels.append(spacer + r'\textbf{' + colname + '}')
+            labels.append(spacer + colname)
+            for key in sorted(legend_mapping[aesthetic]['lookup'].keys()):
+                value = legend_mapping[aesthetic]['lookup'][key]
+                legend_item = make_aesthetic_legend(aesthetic, value)
+                items.append(legend_item)
+                labels.append(key)
 
     legend = ax.legend(items, labels, loc='center left', bbox_to_anchor=(1.05, 0.5), fontsize='small', frameon=False)

ggplot/scales/scale_fill_brewer.py

@@ -0,0 +1,77 @@
+from __future__ import (absolute_import, division, print_function,
+                        unicode_literals)
+from .scale import scale
+from copy import deepcopy
+import brewer2mpl
+
+
+def _number_to_palette(ctype, n):
+    n -= 1
+    palettes = sorted(brewer2mpl.COLOR_MAPS[ctype].keys())
+    if n < len(palettes):
+        return palettes[n]
+
+def _handle_shorthand(text):
+    abbrevs = {
+        "seq": "Sequential",
+        "qual": "Qualitative",
+        "div": "Diverging"
+    }
+    text = abbrevs.get(text, text)
+    text = text.title()
+    return text
+
+class scale_fill_brewer(scale):
+    """
+    Parameters
+    ----------
+    type: string
+        One of seq (sequential), div (diverging) or qual (qualitative)
+    palette: string
+        If a string, will use that named palette. If a number, will index into
+        the list of palettes of appropriate type
+
+    Examples
+    --------
+    >>> from ggplot import *
+    >>> p = ggplot(aes(x='price', fill='clarity'), data=diamonds)
+    >>> p += geom_bar()
+    >>> print(p + scale_fill_brewer(palette=4))
+    >>> print(p + scale_fill_brewer(type='diverging'))
+    >>> print(p + scale_fill_brewer(type='div'))
+    >>> print(p + scale_fill_brewer(type='seq'))
+    >>> print(p + scale_fill_brewer(type='seq', palette='Blues'))
+    """
+    VALID_SCALES = ['type', 'palette']
+
+    def __radd__(self, gg):
+        # gg = deepcopy(gg)
+
+        if self.type:
+            ctype = self.type
+        else:
+            ctype = "Sequential"
+
+        ctype = _handle_shorthand(ctype)
+
+        if self.palette:
+            palette = self.palette
+        else:
+            palette = _number_to_palette(ctype, 1)
+
+        if isinstance(palette, int):
+            palette = _number_to_palette(ctype, palette)
+
+        # color brewer requires a minimum of 3 colors in a palette
+        try:
+            fill_col = gg._aes.data.get('fill')
+            n_colors = max(gg.data[color_col].nunique(), 3)
+        except:
+            # If we are neither using 'color' nor 'fill' then assume there is
+            # only one color used
+            n_colors = 3
+
+        bmap = brewer2mpl.get_map(palette, ctype, n_colors)
+        gg.manual_fill_list = bmap.hex_colors
+
+        return gg