transformConfig.py

Go to the documentation of this file.

# This file is part of afw.
#
# Developed for the LSST Data Management System.
# This product includes software developed by the LSST Project
# (https://www.lsst.org).
# See the COPYRIGHT file at the top-level directory of this distribution
# for details of code ownership.
#
# 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 GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
import functools
import numpy
 
import lsst.geom
from lsst.pex.config import Config, ListField, makeRegistry, \
    ConfigDictField, ConfigurableField
from ._geom import makeTransform, makeIdentityTransform, \
    makeRadialTransform
 
__all__ = ["transformRegistry", "OneTransformConfig", "TransformConfig",
           "IdentityTransformConfig", "AffineTransformConfig", "RadialTransformConfig",
           "MultiTransformConfig"]
 
transformRegistry = makeRegistry(
    """"A registry of ``Transform`` factories
 
    A ``Transform`` factory is a function that obeys these rules:
    - has an attribute ``ConfigClass``
    - takes one argument, ``config`` (an instance of ``ConfigClass``) by name
    - returns a ``Transform``
    """
)
 
 
class IdentityTransformConfig(Config):
    """A Config representing a ``Transform`` that does nothing.
 
    See Also
    --------
    lsst.afw.geom.makeIdentityTransform
    """
    pass
 
 
def identityFactory(config):
    """Make an identity ``Transform``
    """
    return makeIdentityTransform()
 
 
identityFactory.ConfigClass = IdentityTransformConfig
transformRegistry.register("identity", identityFactory)
 
 
class OneTransformConfig(Config):
    """A Config representing a single ``Transform`` in a compound ``Transform``.
 
    See Also
    --------
    lsst.afw.geom.MultiTransformConfig
    """
    transform = ConfigurableField(
        doc="Transform factory",
        target=identityFactory,
    )
 
 
def invertingFactory(config):
    """Invert a ``Transform`` specified by config.
    """
    return config.transform.apply().inverted()
 
 
invertingFactory.ConfigClass = OneTransformConfig
transformRegistry.register("inverted", invertingFactory)
 
 
class AffineTransformConfig(Config):
    """A Config representing an affine ``Transform``.
 
    See Also
    --------
    lsst.afw.geom.makeTransform
    """
    linear = ListField(
        doc="2x2 linear matrix in the usual numpy order; "
            "to rotate a vector by theta use: cos(theta), sin(theta), "
            "-sin(theta), cos(theta)",
        dtype=float,
        length=4,
        default=(1, 0, 0, 1),
    )
    translation = ListField(
        doc="x, y translation vector",
        dtype=float,
        length=2,
        default=(0, 0),
    )
 
 
def affineFactory(config):
    """Make an affine ``Transform``
    """
    linear = numpy.array(config.linear)
    linear.shape = (2, 2)
    translation = numpy.array(config.translation)
    return makeTransform(lsst.geom.AffineTransform(linear, translation))
 
 
affineFactory.ConfigClass = AffineTransformConfig
transformRegistry.register("affine", affineFactory)
 
 
class RadialTransformConfig(Config):
    """A Config representing a radially symmetric ``Transform``.
 
    See Also
    --------
    lsst.afw.geom.makeRadialTransform
    """
    coeffs = ListField(
        doc="Coefficients for the radial polynomial; coeff[0] must be 0",
        dtype=float,
        minLength=1,
        optional=False,
    )
 
    def validate(self):
        if len(self.coeffs) == 0:
            return
        if len(self.coeffs) == 1 or self.coeffs[0] != 0 or self.coeffs[1] == 0:
            raise RuntimeError(
                f"invalid radial transform coeffs {self.coeffs}: "
                "need len(coeffs)=0 or len(coeffs)>1, coeffs[0]==0, "
                "and coeffs[1]!=0")
 
 
def radialFactory(config):
    """Make a radial ``Transform``
    """
    return makeRadialTransform(config.coeffs._list)
 
 
radialFactory.ConfigClass = RadialTransformConfig
transformRegistry.register("radial", radialFactory)
 
 
class MultiTransformConfig(Config):
    """A Config representing a chain of consecutive ``Transforms``.
    """
    transformDict = ConfigDictField(
        doc="Dict of index: OneTransformConfig (a transform wrapper); "
            "key order is transform order",
        keytype=int,
        itemtype=OneTransformConfig,
    )
 
 
def multiFactory(config):
    """Concatenate multiple ``Transforms``
    """
    transformKeys = sorted(config.transformDict.keys())
    transformList = [config.transformDict[key].transform.apply()
                     for key in transformKeys]
 
    # Can't use then(self, other) directly because no single Transform class
    def concat(transform1, transform2):
        return transform1.then(transform2)
 
    return functools.reduce(concat, transformList)
 
 
multiFactory.ConfigClass = MultiTransformConfig
transformRegistry.register("multi", multiFactory)
 
 
class TransformConfig(Config):
    """Config that identifies ``Transforms`` by keyword.
 
    Supported configs:
 
    ``"identity"``
        `IdentityTransformConfig`
    ``"inverted"``
        `OneTransformConfig`
    ``"affine"``
        `AffineTransformConfig`
    ``"radial"``
        `RadialTransformConfig`
    ``"multi"``
        `MultiTransformConfig`
    """
    transform = transformRegistry.makeField(
        doc="a Transform from the registry"
    )