Allow saving callable segmentdata, add diverging map to 'merging cmaps' demo

Author: lukelbd

CHANGELOG.rst

@@ -60,6 +60,21 @@ ProPlot v0.3.0 (2020-01-##)
   with a default ``.proplotrc`` file, change the auto-generated user ``.proplotrc``
   (:pr:`50`).
 
+ProPlot v0.2.8 (2019-12-09)
+===========================
+.. rubric:: Deprecated
+
+- Remove ``'Moisture'`` colormap (:commit:`cf8952b1`).
+
+.. rubric:: Features
+
+- New ``'DryWet'`` colormap is colorblind friendly (:commit:`0280e266`).
+
+.. rubric:: Bug fixes
+
+- Add brute force workaround for saving colormaps with *callable* segmentdata.
+- Save the ``cyclic`` and ``gamma`` attributes in JSON files too.
+
 ProPlot v0.2.7 (2019-12-09)
 ===========================
 

docs/colormaps.ipynb

@@ -188,7 +188,7 @@
     "raw_mimetype": "text/restructuredtext"
    },
    "source": [
-    "To *merge* arbitrary colormaps, simply pass multiple positional arguments to `~proplot.styletools.Colormap`. This lets you create complex `SciVisColor <https://sciviscolor.org/home/colormoves/>`__ style colormaps right inside ProPlot, which may be desirable for complex datasets with complex statistical distributions. In the below example, we reconstruct the colormap from `this SciVisColor example <https://sciviscolor.org/wp-content/uploads/sites/14/2018/04/colormoves-icon-1.png>`__. We also *save* the result for future use by passing ``save=True`` to `~proplot.styletools.Colormap`."
+    "To *merge* arbitrary colormaps, simply pass multiple positional arguments to `~proplot.styletools.Colormap`. This lets you create arbitrary diverging colormaps and segmented `SciVisColor <https://sciviscolor.org/home/colormoves/>`__ style colormaps right inside ProPlot. Segmented colormaps are often desirable for complex datasets with complex statistical distributions. In the below example, we create a new divering colormap and reconstruct the segmented colormap from `this SciVisColor example <https://sciviscolor.org/wp-content/uploads/sites/14/2018/04/colormoves-icon-1.png>`__. We also *save* the results for future use by passing ``save=True`` to `~proplot.styletools.Colormap`."
    ]
   },
   {
@@ -199,23 +199,26 @@
    "source": [
     "import proplot as plot\n",
     "import numpy as np\n",
-    "f, axs = plot.subplots(ncols=2, axwidth=2, span=False)\n",
+    "f, axs = plot.subplots(ncols=3, axwidth=2, span=False)\n",
     "state = np.random.RandomState(51423)\n",
-    "data = state.rand(100, 100).cumsum(axis=1)\n",
-    "# Save colormap as \"test1.json\"\n",
-    "cmap = plot.Colormap('Green1_r', 'Orange5', 'Blue1_r',\n",
-    "                     'Blue6', name='test1', save=True)\n",
-    "m = axs[0].contourf(data, cmap=cmap, levels=100)\n",
-    "f.colorbar(m, loc='b', col=1, locator='none')\n",
-    "# Save colormap as \"test2.json\"\n",
-    "cmap = plot.Colormap('Green1_r', 'Orange5', 'Blue1_r',\n",
-    "                     'Blue6', ratios=(1, 3, 5, 10), name='test2', save=True)\n",
-    "m = axs[1].contourf(data, cmap=cmap, levels=100)\n",
-    "f.colorbar(m, loc='b', col=2, locator='none')\n",
+    "data = state.rand(50, 50).cumsum(axis=1)\n",
+    "# Diverging colormap example\n",
+    "title1 = 'Custom diverging map'\n",
+    "cmap1 = plot.Colormap('Blue2_r', 'RedPurple1', name='Diverging', save=True)\n",
+    "# SciVisColor examples\n",
+    "title2 = 'Custom complex map'\n",
+    "cmap2 = plot.Colormap('Green1_r', 'Orange5', 'Blue1_r',\n",
+    "                      'Blue6', name='Complex', save=True)\n",
+    "title3 = 'SciVisColor example reproduction'\n",
+    "cmap3 = plot.Colormap('Green1_r', 'Orange5', 'Blue1_r',\n",
+    "                      'Blue6', ratios=(1, 3, 5, 10), name='SciVisColor', save=True)\n",
+    "# Plot examples\n",
+    "for ax, cmap, title in zip(axs, (cmap1, cmap2, cmap3), (title1, title2, title3)):\n",
+    "    m = ax.contourf(data, cmap=cmap, levels=256)\n",
+    "    ax.colorbar(m, loc='b', locator='null', label=cmap.name)\n",
+    "    ax.format(title=title)\n",
     "axs.format(xlabel='xlabel', ylabel='ylabel',\n",
-    "           suptitle='Merging existing colormaps')\n",
-    "for ax, title in zip(axs, ['Evenly spaced', 'Matching SciVisColor example']):\n",
-    "    ax.format(title=title)"
+    "           suptitle='Merging existing colormaps')"
    ]
   },
   {

proplot/styletools.py

@@ -256,12 +256,12 @@
 gamma1 : float, optional
     If >1, makes low saturation colors more prominent. If <1,
     makes high saturation colors more prominent. Similar to the
-    `HCLWizard <http://hclwizard.org:64230/hclwizard/>`_ option.
+    `HCLWizard <http://hclwizard.org:64230/hclwizard/>`__ option.
     See `make_mapping_array` for details.
 gamma2 : float, optional
     If >1, makes high luminance colors more prominent. If <1,
     makes low luminance colors more prominent. Similar to the
-    `HCLWizard <http://hclwizard.org:64230/hclwizard/>`_ option.
+    `HCLWizard <http://hclwizard.org:64230/hclwizard/>`__ option.
     See `make_mapping_array` for details.
 gamma : float, optional
     Use this to identically set `gamma1` and `gamma2` at once.
@@ -611,6 +611,16 @@ def make_mapping_array(N, data, gamma=1.0, inverse=False):
         :math:`w_i` ranges from 0 to 1 between rows ``i`` and ``i+1``.
         If `gamma` is float, it applies to every transition. Otherwise,
         its length must equal ``data.shape[0]-1``.
+
+        This is like the `gamma` used with matplotlib's
+        `~matplotlib.colors.makeMappingArray`, except it controls the
+        weighting for transitions *between* each segment data coordinate rather
+        than the coordinates themselves. This makes more sense for
+        `PerceptuallyUniformColormap`\\ s because they usually consist of just
+        one linear transition for *sequential* colormaps and two linear
+        transitions for *diverging* colormaps -- and in the latter case, it
+        is often desirable to modify both "halves" of the colormap in the
+        same way.
     inverse : bool, optional
         If ``True``, :math:`w_i^{\gamma_i}` is replaced with
         :math:`1 - (1 - w_i)^{\gamma_i}` -- that is, when `gamma` is greater
@@ -698,7 +708,6 @@ def make_mapping_array(N, data, gamma=1.0, inverse=False):
 
 class _Colormap():
     """Mixin class used to add some helper methods."""
-
     def _get_data(self, ext):
         """
         Returns a string containing the colormap colors for saving.
@@ -1048,13 +1057,29 @@ def save(self, path=None):
         # Save channel segment data in json file
         _, ext = os.path.splitext(filename)
         if ext[1:] == 'json':
+            # Sanitize segmentdata values
+            # Convert np.float to builtin float, np.array to list of lists,
+            # and callable to list of lists. We tried encoding func.__code__
+            # with base64 and marshal instead, but when cmap.concatenate()
+            # embeds functions as keyword arguments, this seems to make it
+            # *impossible* to load back up the function with FunctionType
+            # (error message: arg 5 (closure) must be tuple). Instead use
+            # this brute force workaround.
             data = {}
             for key, value in self._segmentdata.items():
-                # from np.float to builtin float, and to list of lists
-                data[key] = np.array(value).astype(float).tolist()
+                if callable(value):
+                    x = np.linspace(0, 1, 256)  # just save the transitions
+                    y = np.array([value(_) for _ in x]).squeeze()
+                    value = np.vstack((x, y, y)).T
+                data[key] = np.asarray(value).astype(float).tolist()
+            # Add critical attributes to the dictionary
+            keys = ()
             if isinstance(self, PerceptuallyUniformColormap):
-                for key in ('space', 'gamma1', 'gamma2'):
-                    data[key] = getattr(self, '_' + key)
+                keys = ('cyclic', 'gamma1', 'gamma2', 'space')
+            elif isinstance(self, LinearSegmentedColormap):
+                keys = ('cyclic', 'gamma')
+            for key in keys:
+                data[key] = getattr(self, '_' + key)
             with open(filename, 'w') as file:
                 json.dump(data, file, indent=4)
         # Save lookup table colors
@@ -2681,12 +2706,12 @@ def _load_cmap_cycle(filename, cmap=False):
     if ext == 'json':
         with open(filename, 'r') as f:
             data = json.load(f)
+        kw = {}
+        for key in ('cyclic', 'gamma', 'gamma1', 'gamma2', 'space'):
+            kw[key] = data.pop(key, None)
         if 'red' in data:
             data = LinearSegmentedColormap(name, data, N=N)
         else:
-            kw = {}
-            for key in ('space', 'gamma1', 'gamma2'):
-                kw[key] = data.pop(key, None)
             data = PerceptuallyUniformColormap(name, data, N=N, **kw)
         if name[-2:] == '_r':
             data = data.reversed(name[:-2])