rebuild docs with new discourse on front page

Author: tacaswell

3.1.1/_downloads/00157115776ca5e6a9574f992adbb8a7/demo_curvelinear_grid.py

@@ -0,0 +1,119 @@
+"""
+=====================
+Curvilinear grid demo
+=====================
+
+Custom grid and ticklines.
+
+This example demonstrates how to use
+`~.grid_helper_curvelinear.GridHelperCurveLinear` to define custom grids and
+ticklines by applying a transformation on the grid.  This can be used, as
+shown on the second plot, to create polar projections in a rectangular box.
+"""
+
+import numpy as np
+
+import matplotlib.pyplot as plt
+from matplotlib.projections import PolarAxes
+from matplotlib.transforms import Affine2D
+
+from mpl_toolkits.axisartist import (
+    angle_helper, Subplot, SubplotHost, ParasiteAxesAuxTrans)
+from mpl_toolkits.axisartist.grid_helper_curvelinear import (
+    GridHelperCurveLinear)
+
+
+def curvelinear_test1(fig):
+    """
+    Grid for custom transform.
+    """
+
+    def tr(x, y):
+        x, y = np.asarray(x), np.asarray(y)
+        return x, y - x
+
+    def inv_tr(x, y):
+        x, y = np.asarray(x), np.asarray(y)
+        return x, y + x
+
+    grid_helper = GridHelperCurveLinear((tr, inv_tr))
+
+    ax1 = Subplot(fig, 1, 2, 1, grid_helper=grid_helper)
+    # ax1 will have a ticks and gridlines defined by the given
+    # transform (+ transData of the Axes). Note that the transform of
+    # the Axes itself (i.e., transData) is not affected by the given
+    # transform.
+
+    fig.add_subplot(ax1)
+
+    xx, yy = tr([3, 6], [5, 10])
+    ax1.plot(xx, yy, linewidth=2.0)
+
+    ax1.set_aspect(1)
+    ax1.set_xlim(0, 10)
+    ax1.set_ylim(0, 10)
+
+    ax1.axis["t"] = ax1.new_floating_axis(0, 3)
+    ax1.axis["t2"] = ax1.new_floating_axis(1, 7)
+    ax1.grid(True, zorder=0)
+
+
+def curvelinear_test2(fig):
+    """
+    Polar projection, but in a rectangular box.
+    """
+
+    # PolarAxes.PolarTransform takes radian. However, we want our coordinate
+    # system in degree
+    tr = Affine2D().scale(np.pi/180, 1) + PolarAxes.PolarTransform()
+    # Polar projection, which involves cycle, and also has limits in
+    # its coordinates, needs a special method to find the extremes
+    # (min, max of the coordinate within the view).
+    extreme_finder = angle_helper.ExtremeFinderCycle(
+        nx=20, ny=20,  # Number of sampling points in each direction.
+        lon_cycle=360, lat_cycle=None,
+        lon_minmax=None, lat_minmax=(0, np.inf),
+    )
+    # Find grid values appropriate for the coordinate (degree, minute, second).
+    grid_locator1 = angle_helper.LocatorDMS(12)
+    # Use an appropriate formatter.  Note that the acceptable Locator and
+    # Formatter classes are a bit different than that of Matplotlib, which
+    # cannot directly be used here (this may be possible in the future).
+    tick_formatter1 = angle_helper.FormatterDMS()
+
+    grid_helper = GridHelperCurveLinear(
+        tr, extreme_finder=extreme_finder,
+        grid_locator1=grid_locator1, tick_formatter1=tick_formatter1)
+    ax1 = SubplotHost(fig, 1, 2, 2, grid_helper=grid_helper)
+
+    # make ticklabels of right and top axis visible.
+    ax1.axis["right"].major_ticklabels.set_visible(True)
+    ax1.axis["top"].major_ticklabels.set_visible(True)
+    # let right axis shows ticklabels for 1st coordinate (angle)
+    ax1.axis["right"].get_helper().nth_coord_ticks = 0
+    # let bottom axis shows ticklabels for 2nd coordinate (radius)
+    ax1.axis["bottom"].get_helper().nth_coord_ticks = 1
+
+    fig.add_subplot(ax1)
+
+    ax1.set_aspect(1)
+    ax1.set_xlim(-5, 12)
+    ax1.set_ylim(-5, 10)
+
+    ax1.grid(True, zorder=0)
+
+    # A parasite axes with given transform
+    ax2 = ParasiteAxesAuxTrans(ax1, tr, "equal")
+    # note that ax2.transData == tr + ax1.transData
+    # Anything you draw in ax2 will match the ticks and grids of ax1.
+    ax1.parasites.append(ax2)
+    ax2.plot(np.linspace(0, 30, 51), np.linspace(10, 10, 51), linewidth=2)
+
+
+if __name__ == "__main__":
+    fig = plt.figure(figsize=(7, 4))
+
+    curvelinear_test1(fig)
+    curvelinear_test2(fig)
+
+    plt.show()

3.1.1/_downloads/0035868b7cf7fcb6c06f2b024e2ac642/polygon_selector_demo.py

@@ -0,0 +1,94 @@
+"""
+=====================
+Polygon Selector Demo
+=====================
+
+Shows how one can select indices of a polygon interactively.
+
+"""
+import numpy as np
+
+from matplotlib.widgets import PolygonSelector
+from matplotlib.path import Path
+
+
+class SelectFromCollection(object):
+    """Select indices from a matplotlib collection using `PolygonSelector`.
+
+    Selected indices are saved in the `ind` attribute. This tool fades out the
+    points that are not part of the selection (i.e., reduces their alpha
+    values). If your collection has alpha < 1, this tool will permanently
+    alter the alpha values.
+
+    Note that this tool selects collection objects based on their *origins*
+    (i.e., `offsets`).
+
+    Parameters
+    ----------
+    ax : :class:`~matplotlib.axes.Axes`
+        Axes to interact with.
+
+    collection : :class:`matplotlib.collections.Collection` subclass
+        Collection you want to select from.
+
+    alpha_other : 0 <= float <= 1
+        To highlight a selection, this tool sets all selected points to an
+        alpha value of 1 and non-selected points to `alpha_other`.
+    """
+
+    def __init__(self, ax, collection, alpha_other=0.3):
+        self.canvas = ax.figure.canvas
+        self.collection = collection
+        self.alpha_other = alpha_other
+
+        self.xys = collection.get_offsets()
+        self.Npts = len(self.xys)
+
+        # Ensure that we have separate colors for each object
+        self.fc = collection.get_facecolors()
+        if len(self.fc) == 0:
+            raise ValueError('Collection must have a facecolor')
+        elif len(self.fc) == 1:
+            self.fc = np.tile(self.fc, (self.Npts, 1))
+
+        self.poly = PolygonSelector(ax, self.onselect)
+        self.ind = []
+
+    def onselect(self, verts):
+        path = Path(verts)
+        self.ind = np.nonzero(path.contains_points(self.xys))[0]
+        self.fc[:, -1] = self.alpha_other
+        self.fc[self.ind, -1] = 1
+        self.collection.set_facecolors(self.fc)
+        self.canvas.draw_idle()
+
+    def disconnect(self):
+        self.poly.disconnect_events()
+        self.fc[:, -1] = 1
+        self.collection.set_facecolors(self.fc)
+        self.canvas.draw_idle()
+
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots()
+    grid_size = 5
+    grid_x = np.tile(np.arange(grid_size), grid_size)
+    grid_y = np.repeat(np.arange(grid_size), grid_size)
+    pts = ax.scatter(grid_x, grid_y)
+
+    selector = SelectFromCollection(ax, pts)
+
+    print("Select points in the figure by enclosing them within a polygon.")
+    print("Press the 'esc' key to start a new polygon.")
+    print("Try holding the 'shift' key to move all of the vertices.")
+    print("Try holding the 'ctrl' key to move a single vertex.")
+
+    plt.show()
+
+    selector.disconnect()
+
+    # After figure is closed print the coordinates of the selected points
+    print('\nSelected points:')
+    print(selector.xys[selector.ind])