__init__.py

Go to the documentation of this file.

#
# LSST Data Management System
# Copyright 2008, 2009, 2010 LSST Corporation.
#
# This product includes software developed by the
# LSST Project (http://www.lsst.org/).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the LSST License Statement and
# the GNU General Public License along with this program.  If not,
# see <http://www.lsstcorp.org/LegalNotices/>.
#
 
"""lsst.afw.geom.ellipses
"""
from ._ellipses import *
from ._ellipse import *
from ._axes import *
from ._quadrupole import *
 
Separable = {
    (Distortion, DeterminantRadius): SeparableDistortionDeterminantRadius,
    (Distortion, TraceRadius): SeparableDistortionTraceRadius,
    (Distortion, LogDeterminantRadius): SeparableDistortionLogDeterminantRadius,
    (Distortion, LogTraceRadius): SeparableDistortionLogTraceRadius,
    (ConformalShear, DeterminantRadius): SeparableConformalShearDeterminantRadius,
    (ConformalShear, TraceRadius): SeparableConformalShearTraceRadius,
    (ConformalShear, LogDeterminantRadius): SeparableConformalShearLogDeterminantRadius,
    (ConformalShear, LogTraceRadius): SeparableConformalShearLogTraceRadius
}
 
 
class EllipseMatplotlibInterface:
    """An interface for drawing the ellipse using matplotlib.
 
    This is typically initiated by calling Ellipse.plot(), which
    returns an instance of this class.
    """
 
    def __init__(self, ellipse, scale=1.0, **kwds):
        import matplotlib.patches
        import weakref
        import numpy as np
        self.__ellipse__ellipse = weakref.proxy(ellipse)
        self.scalescale = float(scale)
        core = Axes(self.__ellipse__ellipse.getCore())
        core.scale(2.0 * scale)
        self.patchpatch = matplotlib.patches.Ellipse(
            (self.__ellipse__ellipse.getCenter().getX(), self.__ellipse__ellipse.getCenter().getY()),
            core.getA(), core.getB(), core.getTheta() * 180.0 / np.pi,
            **kwds
        )
 
    def __getattr__(self, name):
        return getattr(self.patchpatch, name)
 
    def update(self, show=True, rescale=True):
        """Update the matplotlib representation to the current ellipse parameters.
        """
        import matplotlib.patches
        import numpy as np
        core = _agl.Axes(self.__ellipse__ellipse.getCore())
        core.scale(2.0 * scale)
        new_patch = matplotlib.patches.Ellipse(
            (self.__ellipse__ellipse.getCenter().getX(), self.__ellipse__ellipse.getCenter().getY()),
            core.a, core.b, core.theta * 180.0 / np.pi
        )
        new_patch.update_from(self.patchpatch)
        axes = self.patchpatch.get_axes()
        if axes is not None:
            self.patchpatch.remove()
            axes.add_patch(new_patch)
        self.patchpatch = new_patch
        if axes is not None:
            if rescale:
                axes.autoscale_view()
            if show:
                axes.figure.canvas.draw()
 
 
def Ellipse_plot(self, axes=None, scale=1.0, show=True, rescale=True, **kwds):
    """Plot the ellipse in matplotlib, adding a MatplotlibInterface
    object as the 'matplotlib' attribute of the ellipse.
 
    Aside from those below, keyword arguments for the
    matplotlib.patches.Patch constructor are also accepted
    ('facecolor', 'linestyle', etc.)
 
    Parameters
    ----------
    axes : `matplotlib.axes.Axes`, optional
        Axes to plot on.  Defaults to matplotlib.pyplot.gca().
    scale : `float`, optional
        Scale the displayed ellipse by this factor.
    show : `bool`, optional
        If True, update the figure automatically.  Set to False for batch
        processing.
    rescale : `bool`, optional
        If True, rescale the axes.
 
    Returns
    -------
    interface : `EllipseMatplotlibInterface`
        An object that allows the matplotlib patch to be updated when the
        ellipse modified.
    """
    import matplotlib.pyplot
    interface = self.MatplotlibInterface(self, scale, **kwds)
    if axes is None:
        axes = matplotlib.pyplot.gca()
    axes.add_patch(interface.patch)
    if rescale:
        axes.autoscale_view()
    if show:
        axes.figure.canvas.draw()
    return interface
 
 
Ellipse.MatplotlibInterface = EllipseMatplotlibInterface
Ellipse.plot = Ellipse_plot