Improved examples, created a new file for generating sample data.'

alvarosg · alvarosg · commit d148756ff5c9 · 2016-10-23T23:52:08.000+01:00
diff --git a/doc/users/plotting/examples/colormap_normalizations_piecewisenorm.py b/doc/users/plotting/examples/colormap_normalizations_piecewisenorm.py
diff --git a/examples/colormap_normalization/colormap_normalizations_piecewisenorm.py b/examples/colormap_normalization/colormap_normalizations_piecewisenorm.py
@@ -0,0 +1,98 @@
+"""
+============================================
+Examples of arbitrary colormap normalization
+============================================
+
+Here I plot an image array with data spanning for a large dynamic range,
+using different normalizations. Look at how each of them enhances
+different features.
+
+"""
+
+from mpl_toolkits.mplot3d import Axes3D
+import matplotlib.colors as colors
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+import numpy as np
+from sampledata import PiecewiseNormData
+
+X, Y, data = PiecewiseNormData()
+cmap = cm.spectral
+
+# Creating functions for plotting
+
+
+def makePlot(norm, label=''):
+    fig, (ax1, ax2) = plt.subplots(1, 2, gridspec_kw={
+        'width_ratios': [1, 2]}, figsize=[9, 4.5])
+    fig.subplots_adjust(top=0.87, left=0.07, right=0.96)
+    fig.suptitle(label)
+
+    cax = ax2.pcolormesh(X, Y, data, cmap=cmap, norm=norm)
+    ticks = cax.norm.ticks() if norm else None
+    cbar = fig.colorbar(cax, format='%.3g', ticks=ticks)
+    ax2.set_xlim(X.min(), X.max())
+    ax2.set_ylim(Y.min(), Y.max())
+
+    data_values = np.linspace(cax.norm.vmin, cax.norm.vmax, 100)
+    cm_values = cax.norm(data_values)
+    ax1.plot(data_values, cm_values)
+    ax1.set_xlabel('Data values')
+    ax1.set_ylabel('Colormap values')
+
+
+def make3DPlot(label=''):
+    fig = plt.figure()
+    fig.suptitle(label)
+    ax = fig.gca(projection='3d')
+    cax = ax.plot_surface(X, Y, data, rstride=1, cstride=1,
+                          cmap=cmap, linewidth=0, antialiased=False)
+    ax.set_zlim(data.min(), data.max())
+    fig.colorbar(cax, shrink=0.5, aspect=5)
+    ax.view_init(20, 225)
+
+
+# Showing how the data looks in linear scale
+make3DPlot('Regular linear scale')
+makePlot(None, 'Regular linear scale')
+
+# Example of logarithm normalization using FuncNorm
+norm = colors.FuncNorm(f=lambda x: np.log10(x),
+                       finv=lambda x: 10.**(x), vmin=0.01, vmax=2)
+makePlot(norm, "Log normalization using FuncNorm")
+# The same can be achived with
+# norm = colors.FuncNorm(f='log',vmin=0.01,vmax=2)
+
+# Example of root normalization using FuncNorm
+norm = colors.FuncNorm(f='sqrt', vmin=0.0, vmax=2)
+makePlot(norm, "Root normalization using FuncNorm")
+
+# Performing a symmetric amplification of the features around 0
+norm = colors.MirrorPiecewiseNorm(fpos='crt')
+makePlot(norm, "Amplified features symetrically around \n"
+               "0 with MirrorPiecewiseNorm")
+
+
+# Amplifying features near 0.6 with MirrorPiecewiseNorm
+norm = colors.MirrorPiecewiseNorm(fpos='crt', fneg='crt',
+                                  center_cm=0.35,
+                                  center_data=0.6)
+makePlot(norm, "Amplifying positive and negative features\n"
+               "standing on 0.6 with MirrorPiecewiseNorm")
+
+# Amplifying features near both -0.4 and near 1.2 with PiecewiseNorm
+norm = colors.PiecewiseNorm(flist=['cubic', 'crt', 'cubic', 'crt'],
+                            refpoints_cm=[0.25, 0.5, 0.75],
+                            refpoints_data=[-0.4, 1, 1.2])
+makePlot(norm, "Amplifying positive and negative features standing\n"
+               " on -0.4 and 1.2 with PiecewiseNorm")
+
+# Amplifying features near both -1, -0.2 and near 1.2 with PiecewiseNorm
+norm = colors.PiecewiseNorm(flist=['crt', 'crt', 'crt'],
+                            refpoints_cm=[0.4, 0.7],
+                            refpoints_data=[-0.2, 1.2])
+makePlot(norm, "Amplifying only positive features standing on -1, -0.2\n"
+               " and 1.2 with PiecewiseNorm")
+
+
+plt.show()
diff --git a/examples/colormap_normalization/sampledata.py b/examples/colormap_normalization/sampledata.py
@@ -0,0 +1,90 @@
+"""
+================================================================
+Creating sample data for the different examples on normalization
+================================================================
+
+Data with special features tailored to the need of the different examples on 
+colormal normalization is created.
+
+"""
+
+import numpy as np
+
+
+def PiecewiseNormData(NX=512, NY=256):
+    """Sample data for the PiecewiseNorm class.
+
+    Returns a 2d array with sample data, along with the X and Y values for the 
+    array.
+
+    Parameters
+    ----------
+    NX : int
+        Number of samples for the data accross the horizontal dimension.
+        Default is 512.
+    NY : int
+        Number of samples for the data accross the vertical dimension.
+        Default is 256.
+
+    Returns
+    -------
+    X, Y, data : ndarray of shape (NX,NY)
+        Values for the `X` coordinates, the `Y` coordinates, and the `data`.
+
+    Examples
+    --------
+    >>> X,Y,Z=PiecewiseNormData()
+    """
+
+    xmax = 16 * np.pi
+    x = np.linspace(0, xmax, NX)
+    y = np.linspace(-2, 2, NY)
+    X, Y = np.meshgrid(x, y)
+
+    data = np.zeros(X.shape)
+
+    def gauss2d(x, y, a0, x0, y0, wx, wy):
+        return a0 * np.exp(-(x - x0)**2 / wx**2 - (y - y0)**2 / wy**2)
+
+    maskY = (Y > -1) * (Y <= 0)
+    N = 31
+    for i in range(N):
+        maskX = (X > (i * (xmax / N))) * (X <= ((i + 1) * (xmax / N)))
+        mask = maskX * maskY
+        data[mask] += gauss2d(X[mask], Y[mask], 2. * i / (N - 1), (i + 0.5) *
+                              (xmax / N), -0.25, xmax / (3 * N), 0.07)
+        data[mask] -= gauss2d(X[mask], Y[mask], 1. * i / (N - 1), (i + 0.5) *
+                              (xmax / N), -0.75, xmax / (3 * N), 0.07)
+
+    maskY = (Y > 0) * (Y <= 1)
+    data[maskY] = np.cos(X[maskY]) * Y[maskY]**2
+
+    N = 61
+    maskY = (Y > 1) * (Y <= 2.)
+    for i, val in enumerate(np.linspace(-1, 1, N)):
+        if val < 0:
+            aux = val
+        if val > 0:
+            aux = val * 2
+
+        maskX = (X >= (i * (xmax / N))) * (X <= ((i + 1) * (xmax / N)))
+        data[maskX * maskY] = aux
+
+    N = 11
+    maskY = (Y <= -1)
+    for i, val in enumerate(np.linspace(-1, 1, N)):
+        if val < 0:
+            factor = 1
+        if val >= 0:
+            factor = 2
+        maskX = (X >= (i * (xmax / N))) * (X <= ((i + 1) * (xmax / N)))
+        mask = maskX * maskY
+        data[mask] = val * factor
+
+        if i != N - 1:
+            data[mask] += gauss2d(X[mask], Y[mask], 0.05 * factor, (i + 0.5) *
+                                  (xmax / N), -1.25, xmax / (3 * N), 0.07)
+        if i != 0:
+            data[mask] -= gauss2d(X[mask], Y[mask], 0.05 * factor, (i + 0.5) *
+                                  (xmax / N), -1.75, xmax / (3 * N), 0.07)
+    return X, Y, data
