|
|
| .. _astropy-visualization-stretchnorm: |
|
|
| ********************************** |
| Image stretching and normalization |
| ********************************** |
|
|
| The `astropy.visualization` module provides a framework for |
| transforming values in images (and more generally any arrays), |
| typically for the purpose of visualization. Two main types of |
| transformations are provided: |
|
|
| * Normalization to the [0:1] range using lower and upper limits where |
| :math:`x` represents the values in the original image: |
|
|
| .. math:: |
|
|
| y = \frac{x - v_{\rm min}}{v_{\rm max} - v_{\rm min}} |
|
|
| * *Stretching* of values in the [0:1] range to the [0:1] range using a |
| linear or non-linear function: |
|
|
| .. math:: |
|
|
| z = f(y) |
|
|
| In addition, classes are provided in order to identify lower and upper |
| limits for a dataset based on specific algorithms (such as using |
| percentiles). |
|
|
| Identifying lower and upper limits, as well as re-normalizing, is |
| described in the `Intervals and Normalization`_ section, while |
| stretching is described in the `Stretching`_ section. |
|
|
| Intervals and Normalization |
| =========================== |
|
|
| Several classes are provided for determining intervals and for |
| normalizing values in this interval to the [0:1] range. One of the |
| simplest examples is the |
| :class:`~astropy.visualization.MinMaxInterval` which determines the |
| limits of the values based on the minimum and maximum values in the |
| array. The class is instantiated with no arguments:: |
| |
| >>> from astropy.visualization import MinMaxInterval |
| >>> interval = MinMaxInterval() |
|
|
| and the limits can be determined by calling the |
| :meth:`~astropy.visualization.MinMaxInterval.get_limits` method, which |
| takes the array of values:: |
| |
| >>> interval.get_limits([1, 3, 4, 5, 6]) |
| (1, 6) |
|
|
| The ``interval`` instance can also be called like a function to |
| actually normalize values to the range:: |
| |
| >>> interval([1, 3, 4, 5, 6]) # doctest: +FLOAT_CMP |
| array([0. , 0.4, 0.6, 0.8, 1. ]) |
|
|
| Other interval classes include |
| :class:`~astropy.visualization.ManualInterval`, |
| :class:`~astropy.visualization.PercentileInterval`, |
| :class:`~astropy.visualization.AsymmetricPercentileInterval`, and |
| :class:`~astropy.visualization.ZScaleInterval`. For these, values in |
| the array can fall outside of the limits given by the interval. A |
| ``clip`` argument is provided to control the behavior of the |
| normalization when values fall outside the limits:: |
| |
| >>> from astropy.visualization import PercentileInterval |
| >>> interval = PercentileInterval(50.) |
| >>> interval.get_limits([1, 3, 4, 5, 6]) |
| (3.0, 5.0) |
| >>> interval([1, 3, 4, 5, 6]) # default is clip=True # doctest: +FLOAT_CMP |
| array([0. , 0. , 0.5, 1. , 1. ]) |
| >>> interval([1, 3, 4, 5, 6], clip=False) # doctest: +FLOAT_CMP |
| array([-1. , 0. , 0.5, 1. , 1.5]) |
|
|
|
|
| Stretching |
| ========== |
|
|
| In addition to classes that can scale values to the [0:1] range, a |
| number of classes are provided to 'stretch' the values using different |
| functions. These map a [0:1] range onto a transformed [0:1] range. A |
| simple example is the :class:`~astropy.visualization.SqrtStretch` |
| class:: |
| |
| >>> from astropy.visualization import SqrtStretch |
| >>> stretch = SqrtStretch() |
| >>> stretch([0., 0.25, 0.5, 0.75, 1.]) # doctest: +FLOAT_CMP |
| array([0. , 0.5 , 0.70710678, 0.8660254 , 1. ]) |
|
|
| As for the intervals, values outside the [0:1] range can be treated |
| differently depending on the ``clip`` argument. By default, output |
| values are clipped to the [0:1] range:: |
| |
| >>> stretch([-1., 0., 0.5, 1., 1.5]) # doctest: +FLOAT_CMP |
| array([0. , 0. , 0.70710678, 1. , 1. ]) |
|
|
| but this can be disabled:: |
| |
| >>> stretch([-1., 0., 0.5, 1., 1.5], clip=False) # doctest: +FLOAT_CMP |
| array([ nan, 0. , 0.70710678, 1. , 1.22474487]) |
|
|
| .. note:: |
| The stretch functions are similar but not always strictly |
| identical to those used in e.g. `DS9 |
| <http://ds9.si.edu/site/Home.html>`_ (although they should have |
| the same behavior). The equations for the DS9 stretches can be |
| found `here <http://ds9.si.edu/doc/ref/how.html>`_ and can be |
| compared to the equations for our stretches provided in the |
| `astropy.visualization` API section. The main difference between |
| our stretches and DS9 is that we have adjusted them so that the |
| [0:1] range always maps exactly to the [0:1] range. |
|
|
|
|
| Combining transformations |
| ========================= |
|
|
| Any intervals and stretches can be chained by using the ``+`` |
| operator, which returns a new transformation. When combining intervals |
| and stretches, the stretch object must come before the interval |
| object. For example, to apply normalization based on a percentile |
| value, followed by a square root stretch, you can do:: |
| |
| >>> transform = SqrtStretch() + PercentileInterval(90.) |
| >>> transform([1, 3, 4, 5, 6]) # doctest: +FLOAT_CMP |
| array([0. , 0.60302269, 0.76870611, 0.90453403, 1. ]) |
|
|
| As before, the combined transformation can also accept a ``clip`` |
| argument (which is `True` by default). |
|
|
| Matplotlib normalization |
| ======================== |
|
|
| Matplotlib allows a custom normalization and stretch to be used when |
| displaying data by passing a :class:`matplotlib.colors.Normalize` |
| object, e.g. to :meth:`~matplotlib.axes.Axes.imshow`. The |
| `astropy.visualization` module provides an |
| :class:`~astropy.visualization.mpl_normalize.ImageNormalize` class |
| that wraps the interval (see `Intervals and Normalization`_) and |
| stretch (see `Stretching`_) objects into an object Matplotlib |
| understands. |
|
|
| The inputs to the |
| :class:`~astropy.visualization.mpl_normalize.ImageNormalize` class are |
| the data and the interval and stretch objects: |
|
|
| .. plot:: |
| :include-source: |
| :align: center |
|
|
| import numpy as np |
| import matplotlib.pyplot as plt |
|
|
| from astropy.visualization import (MinMaxInterval, SqrtStretch, |
| ImageNormalize) |
|
|
| # Generate a test image |
| image = np.arange(65536).reshape((256, 256)) |
|
|
| # Create an ImageNormalize object |
| norm = ImageNormalize(image, interval=MinMaxInterval(), |
| stretch=SqrtStretch()) |
|
|
| # or equivalently using positional arguments |
| # norm = ImageNormalize(image, MinMaxInterval(), SqrtStretch()) |
|
|
| # Display the image |
| fig = plt.figure() |
| ax = fig.add_subplot(1, 1, 1) |
| im = ax.imshow(image, origin='lower', norm=norm) |
| fig.colorbar(im) |
|
|
| As shown above, the colorbar ticks are automatically adjusted. |
|
|
| The input image to :class:`~astropy.visualization.mpl_normalize.ImageNormalize` |
| is typically the one to be displayed, so there is a convenience function |
| :func:`~astropy.visualization.mpl_normalize.imshow_norm` to ease this use case: |
|
|
|
|
| .. plot:: |
| :include-source: |
| :align: center |
|
|
| import numpy as np |
| import matplotlib.pyplot as plt |
|
|
| from astropy.visualization import imshow_norm, MinMaxInterval, SqrtStretch |
|
|
| # Generate a test image |
| image = np.arange(65536).reshape((256, 256)) |
|
|
| # Display the exact same thing as the above plot |
| fig = plt.figure() |
| ax = fig.add_subplot(1, 1, 1) |
| im, norm = imshow_norm(image, ax, origin='lower', |
| interval=MinMaxInterval(), stretch=SqrtStretch()) |
| fig.colorbar(im) |
|
|
| While this is the simplest case, it is also possible for a completely different |
| image to be used to establish the normalization (e.g. if one wants to display |
| several images with exactly the same normalization and stretch). |
|
|
| The inputs to the |
| :class:`~astropy.visualization.mpl_normalize.ImageNormalize` class can |
| also be the vmin and vmax limits, which you can determine from the |
| `Intervals and Normalization`_ classes, and the stretch object: |
|
|
| .. plot:: |
| :include-source: |
| :align: center |
|
|
| import numpy as np |
| import matplotlib.pyplot as plt |
|
|
| from astropy.visualization import (MinMaxInterval, SqrtStretch, |
| ImageNormalize) |
|
|
| # Generate a test image |
| image = np.arange(65536).reshape((256, 256)) |
|
|
| # Create interval object |
| interval = MinMaxInterval() |
| vmin, vmax = interval.get_limits(image) |
|
|
| # Create an ImageNormalize object using a SqrtStretch object |
| norm = ImageNormalize(vmin=vmin, vmax=vmax, stretch=SqrtStretch()) |
|
|
| # Display the image |
| fig = plt.figure() |
| ax = fig.add_subplot(1, 1, 1) |
| im = ax.imshow(image, origin='lower', norm=norm) |
| fig.colorbar(im) |
|
|
| Finally, we also provide a convenience |
| :func:`~astropy.visualization.mpl_normalize.simple_norm` function that |
| can be useful for quick interactive analysis (it is also used by the |
| ``fits2bitmap`` command-line script). However, it is not recommended |
| to be used in scripted programs; it's better to use |
| :class:`~astropy.visualization.mpl_normalize.ImageNormalize` directly: |
|
|
| .. plot:: |
| :include-source: |
| :align: center |
|
|
| import numpy as np |
| import matplotlib.pyplot as plt |
| from astropy.visualization import simple_norm |
|
|
| # Generate a test image |
| image = np.arange(65536).reshape((256, 256)) |
|
|
| # Create an ImageNormalize object |
| norm = simple_norm(image, 'sqrt') |
|
|
| # Display the image |
| fig = plt.figure() |
| ax = fig.add_subplot(1, 1, 1) |
| im = ax.imshow(image, origin='lower', norm=norm) |
| fig.colorbar(im) |
|
|
| Combining stretches and Matplotlib normalization |
| ================================================ |
|
|
| Stretches can also be combined with other stretches, just like transformations. |
| The resulting :class:`~astropy.visualization.stretch.CompositeStretch` can be |
| used to normalize Matplotlib images like any other stretch. For example, a |
| composite stretch can stretch residual images with negative values: |
|
|
| .. plot:: |
| :include-source: |
| :align: center |
|
|
| import numpy as np |
| import matplotlib.pyplot as plt |
| from astropy.visualization.stretch import SinhStretch, LinearStretch |
| from astropy.visualization import ImageNormalize |
|
|
| # Transforms normalized values [0,1] to [-1,1] before stretch and then back |
| stretch = LinearStretch(slope=0.5, intercept=0.5) + SinhStretch() + \ |
| LinearStretch(slope=2, intercept=-1) |
|
|
| # Image of random Gaussian noise |
| image = np.random.normal(size=(64, 64)) |
| fig = plt.figure() |
| ax = fig.add_subplot(1, 1, 1) |
| # ImageNormalize normalizes values to [0,1] before applying the stretch |
| norm = ImageNormalize(stretch=stretch) |
| im = ax.imshow(image, origin='lower', norm=norm, cmap='gray', |
| vmin=-5, vmax=5) |
| fig.colorbar(im) |
|
|
