DM-15139: Rename invert() and getInverse() to inverted()

include/lsst/afw/geom/Transform.h

@@ -48,7 +48,7 @@ class SkyWcs;
  *
  * Depending on the ast::FrameSet or ast::Mapping used to define it, a Transform may
  * provide either a forward transform, an inverse transform, or both. In particular, the
- * @ref getInverse "inverse" of a forward-only transform is an inverse-only transform. The
+ * @ref inverted "inverse" of a forward-only transform is an inverse-only transform. The
  * @ref hasForward and @ref hasInverse methods can be used to check which transforms are available.
  *
  * Unless otherwise stated, all constructors and methods may throw `std::runtime_error` to indicate
@@ -167,15 +167,20 @@ class Transform final : public table::io::PersistableFacade<Transform<FromEndpoi
      */
     FromArray applyInverse(ToArray const &array) const;
 
+    //@{
     /**
      * The inverse of this Transform.
      *
      * @returns a Transform whose `applyForward` is equivalent to this Transform's
      *          `applyInverse`, and vice versa.
      *
+     * @deprecated `getInverse` is deprecated in favor of `inverted`
+     *
      * @exceptsafe Provides basic exception safety.
      */
-    std::shared_ptr<Transform<ToEndpoint, FromEndpoint>> getInverse() const;
+    std::shared_ptr<Transform<ToEndpoint, FromEndpoint>> inverted() const;
+    std::shared_ptr<Transform<ToEndpoint, FromEndpoint>> getInverse() const { return inverted(); };
+    //@}
 
     /**
      * The Jacobian matrix of this Transform.

include/lsst/afw/geom/ellipses/GridTransform.h

@@ -65,8 +65,15 @@ class BaseCore::GridTransform {
     /// Return the determinant of the lsst::geom::LinearTransform.
     double getDeterminant() const;
 
-    /// Return the inverse of the lsst::geom::LinearTransform;
-    lsst::geom::LinearTransform invert() const;
+    //@{
+    /**
+     * Return the inverse of the lsst::geom::LinearTransform;
+     *
+     * @deprecated invert is deprecated in favor of inverted
+     */
+    lsst::geom::LinearTransform inverted() const;
+    lsst::geom::LinearTransform invert() const { return inverted(); };
+    //@}
 
 private:
     BaseCore const& _input;  ///< @internal input core to be transformed
@@ -98,7 +105,8 @@ class Ellipse::GridTransform {
     operator lsst::geom::AffineTransform() const;
 
     /// Return the inverse of the AffineTransform.
-    lsst::geom::AffineTransform invert() const;
+    lsst::geom::AffineTransform inverted() const;
+    lsst::geom::AffineTransform invert() const { return inverted(); };
 
 private:
     Ellipse const& _input;  ///< @internal input ellipse to be transformed

python/lsst/afw/cameraGeom/makePixelToTanPixel.py

@@ -47,6 +47,6 @@ def makePixelToTanPixel(bbox, orientation, focalPlaneToField, pixelSizeMm):
     # so the same consideration applies to pixelToField)
     pixAtFieldCtr = pixelToField.applyInverse(lsst.geom.Point2D(0, 0))
     tanPixToFieldAffine = lsst.afw.geom.linearizeTransform(pixelToField, pixAtFieldCtr)
-    fieldToTanPix = lsst.afw.geom.makeTransform(tanPixToFieldAffine.invert())
+    fieldToTanPix = lsst.afw.geom.makeTransform(tanPixToFieldAffine.inverted())
 
     return pixelToField.then(fieldToTanPix)

python/lsst/afw/geom/testUtils.py

@@ -230,7 +230,7 @@ def makeSipIwcToPixel(metadata):
     coeffArr = np.array(coeffList, dtype=float)
     sipPolyMap = ast.PolyMap(coeffArr, 2, "IterInverse=0")
 
-    iwcToPixelMap = cdMatrixMap.getInverse().then(sipPolyMap).then(pixelRelativeToAbsoluteMap)
+    iwcToPixelMap = cdMatrixMap.inverted().then(sipPolyMap).then(pixelRelativeToAbsoluteMap)
     return afwGeom.TransformPoint2ToPoint2(iwcToPixelMap)
 
 
@@ -262,7 +262,7 @@ def makeSipPixelToIwc(metadata):
         where dxy = pixelPosition - pixelOrigin
     """
     crpix = (metadata.getScalar("CRPIX1") - 1, metadata.getScalar("CRPIX2") - 1)
-    pixelAbsoluteToRelativeMap = ast.ShiftMap(crpix).getInverse()
+    pixelAbsoluteToRelativeMap = ast.ShiftMap(crpix).inverted()
     cdMatrix = getCdMatrixFromMetadata(metadata)
     cdMatrixMap = ast.MatrixMap(cdMatrix.copy())
     coeffList = makeSipPolyMapCoeffs(metadata, "A") + makeSipPolyMapCoeffs(metadata, "B")
@@ -798,7 +798,7 @@ def checkTransformFromMapping(self, fromName, toName):
             self.checkTransformation(transform, polyMap, msg=msg)
 
             # Inverse transform but no forward
-            polyMap = makeForwardPolyMap(nOut, nIn).getInverse()
+            polyMap = makeForwardPolyMap(nOut, nIn).inverted()
             transform = TransformClass(polyMap)
             self.checkTransformation(transform, polyMap, msg=msg)
 
@@ -890,8 +890,10 @@ def checkTransformFromFrameSet(self, fromName, toName):
                 permTransform = TransformClass(permutedFS.frameSet)
                 self.checkTransformation(permTransform, mapping=polyMap, msg=msg)
 
-    def checkGetInverse(self, fromName, toName):
-        """Test Transform<fromName>To<toName>.getInverse
+    def checkInverted(self, fromName, toName):
+        """Test Transform<fromName>To<toName>.inverted
+
+        and the deprecated old name getInverse
 
         Parameters
         ----------
@@ -915,13 +917,16 @@ def checkGetInverse(self, fromName, toName):
                 "{}, Map={}".format(msg, "Forward"))
             self.checkInverseMapping(
                 TransformClass,
-                makeForwardPolyMap(nOut, nIn).getInverse(),
+                makeForwardPolyMap(nOut, nIn).inverted(),
                 "{}, Map={}".format(msg, "Inverse"))
 
     def checkInverseMapping(self, TransformClass, mapping, msg):
-        """Test Transform<fromName>To<toName>.getInverse for a specific
+        """Test Transform<fromName>To<toName>.inverted for a specific
         mapping.
 
+        Also check that inverted() and getInverted() return the same
+        transform.
+
         Parameters
         ----------
         TransformClass : `type`
@@ -932,13 +937,16 @@ def checkInverseMapping(self, TransformClass, mapping, msg):
             Error message suffix
         """
         transform = TransformClass(mapping)
-        inverse = transform.getInverse()
-        inverseInverse = inverse.getInverse()
+        inverse = transform.inverted()
+        inverseInverse = inverse.inverted()
 
         self.checkInverseTransformation(transform, inverse, msg=msg)
         self.checkInverseTransformation(inverse, inverseInverse, msg=msg)
         self.checkTransformation(inverseInverse, mapping, msg=msg)
 
+        inverse2 = transform.getInverse()
+        self.assertEqual(inverse.getMapping(), inverse2.getMapping())
+
     def checkGetJacobian(self, fromName, toName):
         """Test Transform<fromName>To<toName>.getJacobian
 

python/lsst/afw/geom/transform/transform.cc

@@ -93,6 +93,7 @@ void declareTransform(py::module &mod) {
     cls.def("applyForward", (ToPoint(Class::*)(FromPoint const &) const) & Class::applyForward, "point"_a);
     cls.def("applyInverse", (FromArray(Class::*)(ToArray const &) const) & Class::applyInverse, "array"_a);
     cls.def("applyInverse", (FromPoint(Class::*)(ToPoint const &) const) & Class::applyInverse, "point"_a);
+    cls.def("inverted", &Class::inverted);
     cls.def("getInverse", &Class::getInverse);
     /* Need some extra handling of ndarray return type in Python to prevent dimensions
      * of length 1 from being deleted */

python/lsst/afw/geom/transformConfig.py

@@ -80,7 +80,7 @@ class OneTransformConfig(Config):
 def invertingFactory(config):
     """Invert a ``Transform`` specified by config.
     """
-    return config.transform.apply().getInverse()
+    return config.transform.apply().inverted()
 
 
 invertingFactory.ConfigClass = OneTransformConfig

python/lsst/afw/geom/wcsUtils/wcsUtilsContinued.py

@@ -180,5 +180,5 @@ def computePixelToDistortedPixel(pixelToFocalPlane, focalPlaneToFieldAngle):
     focalPlaneToTanFieldAngle = makeTransform(linearizeTransform(focalPlaneToFieldAngle,
                                                                  lsst.geom.Point2D(0, 0)))
     return pixelToFocalPlane.then(focalPlaneToFieldAngle) \
-        .then(focalPlaneToTanFieldAngle.getInverse()) \
-        .then(pixelToFocalPlane.getInverse())
+        .then(focalPlaneToTanFieldAngle.inverted()) \
+        .then(pixelToFocalPlane.inverted())

src/cameraGeom/Orientation.cc

@@ -106,7 +106,7 @@ std::shared_ptr<afw::geom::TransformPoint2ToPoint2> Orientation::makePixelFpTran
 
 std::shared_ptr<afw::geom::TransformPoint2ToPoint2> Orientation::makeFpPixelTransform(
         lsst::geom::Extent2D const pixelSizeMm) const {
-    return makePixelFpTransform(pixelSizeMm)->getInverse();
+    return makePixelFpTransform(pixelSizeMm)->inverted();
 }
 
 }  // namespace cameraGeom

src/geom/SkyWcs.cc

@@ -145,7 +145,7 @@ Eigen::Matrix2d makeCdMatrix(lsst::geom::Angle const& scale, lsst::geom::Angle c
 }
 
 std::shared_ptr<TransformPoint2ToPoint2> makeWcsPairTransform(SkyWcs const& src, SkyWcs const& dst) {
-    auto const dstInverse = dst.getTransform()->getInverse();
+    auto const dstInverse = dst.getTransform()->inverted();
     return src.getTransform()->then(*dstInverse);
 }
 
@@ -411,7 +411,7 @@ lsst::geom::AffineTransform SkyWcs::_linearizeSkyToPixel(lsst::geom::Point2D con
                                                          lsst::geom::SpherePoint const& coord,
                                                          lsst::geom::AngleUnit const& skyUnit) const {
     lsst::geom::AffineTransform inverse = _linearizePixelToSky(pix00, coord, skyUnit);
-    return inverse.invert();
+    return inverse.inverted();
 }
 
 std::shared_ptr<SkyWcs> makeFlippedWcs(SkyWcs const& wcs, bool flipLR, bool flipTB,
@@ -451,17 +451,17 @@ std::shared_ptr<SkyWcs> makeModifiedWcs(TransformPoint2ToPoint2 const& pixelTran
         auto const oldActualPixelToPixels = oldFrameDict->getMapping("ACTUAL_PIXELS", "PIXELS");
         std::shared_ptr<ast::Mapping> newActualPixelsToPixels;
         if (modifyActualPixels) {
-            newActualPixelsToPixels = pixelMapping->then(*oldActualPixelToPixels).simplify();
+            newActualPixelsToPixels = pixelMapping->then(*oldActualPixelToPixels).simplified();
             newPixelToIwc = oldPixelToIwc;
         } else {
             newActualPixelsToPixels = oldActualPixelToPixels;
-            newPixelToIwc = pixelMapping->then(*oldPixelToIwc).simplify();
+            newPixelToIwc = pixelMapping->then(*oldPixelToIwc).simplified();
         }
         newFrameDict =
                 std::make_shared<ast::FrameDict>(*actualPixelFrame, *newActualPixelsToPixels, *pixelFrame);
         newFrameDict->addFrame("PIXELS", *newPixelToIwc, *iwcFrame);
     } else {
-        newPixelToIwc = pixelMapping->then(*oldPixelToIwc).simplify();
+        newPixelToIwc = pixelMapping->then(*oldPixelToIwc).simplified();
         newFrameDict = std::make_shared<ast::FrameDict>(*pixelFrame, *newPixelToIwc, *iwcFrame);
     }
     newFrameDict->addFrame("IWC", *iwcToSky, *skyFrame);

src/geom/Transform.cc

@@ -43,7 +43,7 @@ namespace geom {
 template <class FromEndpoint, class ToEndpoint>
 Transform<FromEndpoint, ToEndpoint>::Transform(ast::Mapping const &mapping, bool simplify)
         : _fromEndpoint(mapping.getNIn()),
-          _mapping(simplify ? mapping.simplify() : mapping.copy()),
+          _mapping(simplify ? mapping.simplified() : mapping.copy()),
           _toEndpoint(mapping.getNOut()) {}
 
 template <typename FromEndpoint, typename ToEndpoint>
@@ -67,7 +67,7 @@ Transform<FromEndpoint, ToEndpoint>::Transform(ast::FrameSet const &frameSet, bo
     _fromEndpoint.normalizeFrame(frameSetCopy);
     frameSetCopy->setBase(baseIndex);
     frameSetCopy->setCurrent(currentIndex);
-    _mapping = simplify ? frameSetCopy->getMapping()->simplify() : frameSetCopy->getMapping();
+    _mapping = simplify ? frameSetCopy->getMapping()->simplified() : frameSetCopy->getMapping();
 }
 
 template <typename FromEndpoint, typename ToEndpoint>
@@ -107,12 +107,12 @@ typename FromEndpoint::Array Transform<FromEndpoint, ToEndpoint>::applyInverse(
 }
 
 template <class FromEndpoint, class ToEndpoint>
-std::shared_ptr<Transform<ToEndpoint, FromEndpoint>> Transform<FromEndpoint, ToEndpoint>::getInverse() const {
-    auto inverse = std::dynamic_pointer_cast<ast::Mapping>(_mapping->getInverse());
+std::shared_ptr<Transform<ToEndpoint, FromEndpoint>> Transform<FromEndpoint, ToEndpoint>::inverted() const {
+    auto inverse = std::dynamic_pointer_cast<ast::Mapping>(_mapping->inverted());
     if (!inverse) {
         // don't throw std::bad_cast because it doesn't let you provide debugging info
         std::ostringstream buffer;
-        buffer << "Mapping.getInverse() does not return a Mapping. Called from: " << _mapping;
+        buffer << "Mapping.inverted() does not return a Mapping. Called from: " << _mapping;
         throw LSST_EXCEPT(pex::exceptions::LogicError, buffer.str());
     }
     return std::make_shared<Transform<ToEndpoint, FromEndpoint>>(*inverse);
@@ -173,7 +173,7 @@ std::shared_ptr<Transform<FromEndpoint, NextToEndpoint>> Transform<FromEndpoint,
         auto nextMapping = next.getMapping();
         auto combinedMapping = getMapping()->then(*next.getMapping());
         if (simplify) {
-            return std::make_shared<Transform<FromEndpoint, NextToEndpoint>>(*combinedMapping.simplify());
+            return std::make_shared<Transform<FromEndpoint, NextToEndpoint>>(*combinedMapping.simplified());
         } else {
             return std::make_shared<Transform<FromEndpoint, NextToEndpoint>>(combinedMapping);
         }

src/geom/detail/frameSetUtils.cc

@@ -216,7 +216,7 @@ std::shared_ptr<ast::FrameDict> readLsstSkyWcs(daf::base::PropertySet& metadata,
     // Note: we use stdSkyFrameSet as the new frame (meaning stdSkyFrameSet's current frame),
     // because, unlike stdSkyFrameTemplate, stdSkyFrameSet's current frame has inherited some
     // potentially useful attributes from the old sky frame, such as epoch.
-    rawFrameSet->addFrame(initialSkyIndex, *stdSkyFrameSet->getMapping()->simplify(),
+    rawFrameSet->addFrame(initialSkyIndex, *stdSkyFrameSet->getMapping()->simplified(),
                           *stdSkyFrameSet->getFrame(ast::FrameSet::CURRENT));
     auto const stdSkyIndex = rawFrameSet->getCurrent();
     auto const stdSkyFrame = rawFrameSet->getFrame(stdSkyIndex, false);
@@ -228,8 +228,8 @@ std::shared_ptr<ast::FrameDict> readLsstSkyWcs(daf::base::PropertySet& metadata,
     auto pixelToGrid = ast::ShiftMap(pixelToGridArray);
 
     // Now construct the returned FrameDict
-    auto const gridToIwc = rawFrameSet->getMapping(gridIndex, iwcIndex)->simplify();
-    auto const pixelToIwc = pixelToGrid.then(*gridToIwc).simplify();
+    auto const gridToIwc = rawFrameSet->getMapping(gridIndex, iwcIndex)->simplified();
+    auto const pixelToIwc = pixelToGrid.then(*gridToIwc).simplified();
     auto const iwcToStdSky = rawFrameSet->getMapping(iwcIndex, stdSkyIndex);
 
     auto frameDict = std::make_shared<ast::FrameDict>(ast::Frame(2, "Domain=PIXELS"), *pixelToIwc, *iwcFrame);

src/geom/ellipses/GridTransform.cc

@@ -93,7 +93,7 @@ BaseCore::GridTransform::DerivativeMatrix BaseCore::GridTransform::d() const {
 
 double BaseCore::GridTransform::getDeterminant() const { return sqrt(1.0 / _eig.eigenvalues().prod()); }
 
-lsst::geom::LinearTransform BaseCore::GridTransform::invert() const {
+lsst::geom::LinearTransform BaseCore::GridTransform::inverted() const {
     return lsst::geom::LinearTransform(_eig.operatorSqrt());
 }
 
@@ -139,8 +139,8 @@ Ellipse::GridTransform::operator lsst::geom::AffineTransform() const {
     return lsst::geom::AffineTransform(linear, linear(lsst::geom::Point2D() - _input.getCenter()));
 }
 
-lsst::geom::AffineTransform Ellipse::GridTransform::invert() const {
-    return lsst::geom::AffineTransform(_coreGt.invert(), lsst::geom::Extent2D(_input.getCenter()));
+lsst::geom::AffineTransform Ellipse::GridTransform::inverted() const {
+    return lsst::geom::AffineTransform(_coreGt.inverted(), lsst::geom::Extent2D(_input.getCenter()));
 }
 }  // namespace ellipses
 }  // namespace geom

src/geom/transformFactory.cc

@@ -158,7 +158,7 @@ std::shared_ptr<TransformPoint2ToPoint2> makeTransform(lsst::geom::AffineTransfo
     Point2Endpoint toEndpoint;
     auto const map = ast::MatrixMap(toNdArray(jacobian))
                              .then(ast::ShiftMap(toEndpoint.dataFromPoint(offset)))
-                             .simplify();
+                             .simplified();
     return std::make_shared<TransformPoint2ToPoint2>(*map);
 }
 
@@ -206,7 +206,7 @@ std::shared_ptr<TransformPoint2ToPoint2> makeRadialTransform(std::vector<double>
     // the polynomial has coefficients specified for both the forward and inverse directions
     std::vector<double> center = {0.0, 0.0};
     ast::PolyMap const forward = makeOneDDistortion(forwardCoeffs);
-    auto inverse = makeOneDDistortion(inverseCoeffs).getInverse();
+    auto inverse = makeOneDDistortion(inverseCoeffs).inverted();
     auto distortion = ast::TranMap(forward, *inverse);
     return std::make_shared<TransformPoint2ToPoint2>(*ast::makeRadialMapping(center, distortion));
 }

src/math/warpExposure.cc

@@ -319,7 +319,7 @@ int warpImage(DestImageT &destImage, SrcImageT const &srcImage,
     int numGoodPixels = 0;
 
     // compute a transform from local destination pixels to parent source pixels
-    auto const parentDestToParentSrc = srcToDest.getInverse();
+    auto const parentDestToParentSrc = srcToDest.inverted();
     std::vector<double> const localDestToParentDestVec = {static_cast<double>(destImage.getX0()),
                                                           static_cast<double>(destImage.getY0())};
     auto const localDestToParentDest = geom::TransformPoint2ToPoint2(ast::ShiftMap(localDestToParentDestVec));

tests/ellipse.cc

@@ -316,8 +316,8 @@ struct GridTransformTest {
                 boost::str(boost::format("GridTransform::d failed for %s:\nAnalytic:\n%s\nNumeric:\n%s\n") %
                            core.getName() % d_analytic % d_numeric));
 
-        lsst::geom::AffineTransform inverse1 = input.getGridTransform().invert();
-        lsst::geom::AffineTransform inverse2 = lsst::geom::AffineTransform(input.getGridTransform()).invert();
+        lsst::geom::AffineTransform inverse1 = input.getGridTransform().inverted();
+        lsst::geom::AffineTransform inverse2 = lsst::geom::AffineTransform(input.getGridTransform()).inverted();
         static double const TRANSFORM_INVERSE_EPSILON = 1E-8;
         BOOST_CHECK_CLOSE(inverse1[0], inverse2[0], TRANSFORM_INVERSE_EPSILON);
         BOOST_CHECK_CLOSE(inverse1[1], inverse2[1], TRANSFORM_INVERSE_EPSILON);

tests/test_skyWcs.py

@@ -37,7 +37,7 @@ def addActualPixelsFrame(skyWcs, actualPixelsToPixels):
     actualPixelsToPixelsMap = actualPixelsToPixels.getMapping()
     actualPixelsFrame = ast.Frame(2, "Domain=ACTUAL_PIXELS")
     frameDict = skyWcs.getFrameDict()
-    frameDict.addFrame("PIXELS", actualPixelsToPixelsMap.getInverse(), actualPixelsFrame)
+    frameDict.addFrame("PIXELS", actualPixelsToPixelsMap.inverted(), actualPixelsFrame)
     frameDict.setBase("ACTUAL_PIXELS")
     frameDict.setCurrent("SKY")
     return SkyWcs(frameDict)

tests/test_transform.py

@@ -37,7 +37,7 @@ def testTransforms(self):
             for toName in self.endpointPrefixes:
                 self.checkTransformFromMapping(fromName, toName)
                 self.checkTransformFromFrameSet(fromName, toName)
-                self.checkGetInverse(fromName, toName)
+                self.checkInverted(fromName, toName)
                 self.checkGetJacobian(fromName, toName)
                 for midName in self.endpointPrefixes:
                     self.checkThen(fromName, midName, toName)

tests/test_transformFactory.py

@@ -117,7 +117,7 @@ def checkLinearize(self, transform, invertible):
         if invertible:
             rng = np.random.RandomState(42)
             nDelta = 100
-            inverse = affine.invert()
+            inverse = affine.inverted()
             deltaFrom = rng.normal(0.0, 10.0, (nIn, nDelta))
             for i in range(nDelta):
                 pointMsg = "{}, point={}".format(msg, tweakedInPoint)
@@ -136,7 +136,7 @@ def checkLinearize(self, transform, invertible):
         else:
             # TODO: replace with correct type after fixing DM-11248
             with self.assertRaises(Exception):
-                affine.invert()
+                affine.inverted()
 
         # Can't test exceptions without reliable way to make invalid transform