lsst · r-owen · Jun 15, 2017 · Jun 2, 2017
diff --git a/examples/timeWarpExposureUsingTransform.py b/examples/timeWarpExposureUsingTransform.py
@@ -90,7 +90,7 @@ def run():
     srcWcs = afwGeom.SkyWcs(srcMetadata)
     srcDim = srcExposure.getDimensions()
     srcCtrPos = afwGeom.Box2D(srcMaskedImage.getBBox()).getCenter()
-    srcCtrSky = srcWcs.tranForward(srcCtrPos)
+    srcCtrSky = srcWcs.applyForward(srcCtrPos)
     srcScale = srcWcs.getPixelScale()
 
     # make the destination exposure small enough that even after rotation and offset

diff --git a/include/lsst/afw/geom/Endpoint.h b/include/lsst/afw/geom/Endpoint.h
@@ -46,7 +46,7 @@ Each type of endpoint is used for a particular LSST data type, for example:
 - Point2Endpoint is used for Point2D data
 - SpherePointEndpoint for SpherePoint data
 - GenericEndpoint is used when no other form will do; its LSST data type
-  is identical to the type used for ast::Mapping.tranForward.
+  is identical to the type used for ast::Mapping.applyForward.
 
 Endpoints use the following forms of data for raw data:
 - std::vector<double> for a single point

diff --git a/include/lsst/afw/geom/SkyWcs.h b/include/lsst/afw/geom/SkyWcs.h
@@ -185,25 +185,25 @@ class SkyWcs : public Transform<Point2Endpoint, SpherePointEndpoint> {
     /**
     Compute sky position(s) from pixel position(s)
 
-    This is another name for tranForward, plus an overload that takes a pair of doubles.
+    This is another name for applyForward, plus an overload that takes a pair of doubles.
     */
     //@{
     std::pair<Angle, Angle> pixelToSky(double x, double y) const;
-    SpherePoint pixelToSky(Point2D const &pixel) const { return tranForward(pixel); };
+    SpherePoint pixelToSky(Point2D const &pixel) const { return applyForward(pixel); };
     std::vector<SpherePoint> pixelToSky(std::vector<Point2D> const &pixels) const {
-        return tranForward(pixels);
+        return applyForward(pixels);
     }
     //@}
 
     /**
     Compute pixel position(s) from sky position(s)
 
-    This is another name for tranInverse, plus an overload that takes a pair of lsst:afw::geom::Angle.
+    This is another name for applyInverse, plus an overload that takes a pair of lsst:afw::geom::Angle.
     */
     //@{
     std::pair<double, double> skyToPixel(Angle const &ra, Angle const &dec) const;
-    Point2D skyToPixel(SpherePoint const &sky) const { return tranInverse(sky); }
-    std::vector<Point2D> skyToPixel(std::vector<SpherePoint> const &sky) const { return tranInverse(sky); }
+    Point2D skyToPixel(SpherePoint const &sky) const { return applyInverse(sky); }
+    std::vector<Point2D> skyToPixel(std::vector<SpherePoint> const &sky) const { return applyInverse(sky); }
     //@}
 
 private:

diff --git a/include/lsst/afw/geom/Transform.h b/include/lsst/afw/geom/Transform.h
@@ -56,7 +56,7 @@ internal errors within AST.
 @note You gain some safety by constructing a Transform from an ast::FrameSet,
 since the base and current frames in the FrameSet can be checked against by the appropriate endpoint.
 
-@note "In place" versions of `tranForward` and `tranInverse` are not available
+@note "In place" versions of `applyForward` and `applyInverse` are not available
 because data must be copied when converting from LSST data types to the type used by astshim,
 so it didn't seem worth the bother.
 */
@@ -141,7 +141,7 @@ class Transform {
     /**
     Transform one point in the forward direction ("from" to "to")
     */
-    ToPoint tranForward(FromPoint const &point) const;
+    ToPoint applyForward(FromPoint const &point) const;
 
     /**
     Transform an array of points in the forward direction ("from" to "to")
@@ -150,12 +150,12 @@ class Transform {
     values for the first axis, then values for the next axis, and so on, e.g. for 2 axes:
         x0, x1, x2, ..., y0, y1, y2...
     */
-    ToArray tranForward(FromArray const &array) const;
+    ToArray applyForward(FromArray const &array) const;
 
     /**
     Transform one point in the inverse direction ("to" to "from")
     */
-    FromPoint tranInverse(ToPoint const &point) const;
+    FromPoint applyInverse(ToPoint const &point) const;
 
     /**
     Transform an array of points in the inverse direction ("to" to "from")
@@ -164,13 +164,13 @@ class Transform {
     values for the first axis, then values for the next axis, and so on, e.g. for 2 axes:
         x0, x1, x2, ..., y0, y1, y2...
     */
-    FromArray tranInverse(ToArray const &array) const;
+    FromArray applyInverse(ToArray const &array) const;
 
     /**
      * The inverse of this Transform.
      *
-     * @returns a Transform whose `tranForward` is equivalent to this Transform's
-     *          `tranInverse`, and vice versa.
+     * @returns a Transform whose `applyForward` is equivalent to this Transform's
+     *          `applyInverse`, and vice versa.
      *
      * @exceptsafe Provides basic exception safety.
      */
@@ -193,7 +193,7 @@ class Transform {
      * @note The derivatives may be estimated by sampling and interpolating
      *       this Transform in the neighborhood of `x`. If the implementation
      *       requires interpolation, computation of the Jacobian may require
-     *       hundreds of evaluations of @ref tranForward.
+     *       hundreds of evaluations of @ref applyForward.
      */
     Eigen::MatrixXd getJacobian(FromPoint const &x) const;
 

diff --git a/python/lsst/afw/geom/testUtils.py b/python/lsst/afw/geom/testUtils.py
@@ -488,7 +488,7 @@ def makeJacobian(nIn, nOut, inPoint):
         return coeffs
 
     def checkTransformation(self, transform, mapping, msg=""):
-        """Check tranForward and tranInverse for a transform
+        """Check applyForward and applyInverse for a transform
 
         Parameters
         ----------
@@ -522,15 +522,15 @@ def checkTransformation(self, transform, mapping, msg=""):
 
         if mapping.hasForward:
             self.assertTrue(transform.hasForward)
-            outPoint = transform.tranForward(inPoint)
+            outPoint = transform.applyForward(inPoint)
             rawOutPoint = toEndpoint.dataFromPoint(outPoint)
-            assert_allclose(rawOutPoint, mapping.tranForward(rawInPoint), err_msg=msg)
-            assert_allclose(rawOutPoint, frameSet.tranForward(rawInPoint), err_msg=msg)
+            assert_allclose(rawOutPoint, mapping.applyForward(rawInPoint), err_msg=msg)
+            assert_allclose(rawOutPoint, frameSet.applyForward(rawInPoint), err_msg=msg)
 
-            outArray = transform.tranForward(inArray)
+            outArray = transform.applyForward(inArray)
             rawOutArray = toEndpoint.dataFromArray(outArray)
-            self.assertFloatsAlmostEqual(rawOutArray, mapping.tranForward(rawInArray), msg=msg)
-            self.assertFloatsAlmostEqual(rawOutArray, frameSet.tranForward(rawInArray), msg=msg)
+            self.assertFloatsAlmostEqual(rawOutArray, mapping.applyForward(rawInArray), msg=msg)
+            self.assertFloatsAlmostEqual(rawOutArray, frameSet.applyForward(rawInArray), msg=msg)
         else:
             # Need outPoint, but don't need it to be consistent with inPoint
             rawOutPoint = self.makeRawPointData(nOut)
@@ -545,18 +545,18 @@ def checkTransformation(self, transform, mapping, msg=""):
             # inverse transformation of one point;
             # remember that the inverse need not give the original values
             # (see the description of the `mapping` parameter)
-            inversePoint = transform.tranInverse(outPoint)
+            inversePoint = transform.applyInverse(outPoint)
             rawInversePoint = fromEndpoint.dataFromPoint(inversePoint)
-            assert_allclose(rawInversePoint, mapping.tranInverse(rawOutPoint), err_msg=msg)
-            assert_allclose(rawInversePoint, frameSet.tranInverse(rawOutPoint), err_msg=msg)
+            assert_allclose(rawInversePoint, mapping.applyInverse(rawOutPoint), err_msg=msg)
+            assert_allclose(rawInversePoint, frameSet.applyInverse(rawOutPoint), err_msg=msg)
 
             # inverse transformation of an array of points;
             # remember that the inverse will not give the original values
             # (see the description of the `mapping` parameter)
-            inverseArray = transform.tranInverse(outArray)
+            inverseArray = transform.applyInverse(outArray)
             rawInverseArray = fromEndpoint.dataFromArray(inverseArray)
-            self.assertFloatsAlmostEqual(rawInverseArray, mapping.tranInverse(rawOutArray), msg=msg)
-            self.assertFloatsAlmostEqual(rawInverseArray, frameSet.tranInverse(rawOutArray), msg=msg)
+            self.assertFloatsAlmostEqual(rawInverseArray, mapping.applyInverse(rawOutArray), msg=msg)
+            self.assertFloatsAlmostEqual(rawInverseArray, frameSet.applyInverse(rawOutArray), msg=msg)
         else:
             self.assertFalse(transform.hasInverse)
 
@@ -601,28 +601,28 @@ def checkInverseTransformation(self, forward, inverse, msg=""):
         outArray = toEndpoint.arrayFromData(rawOutArray)
 
         if forward.hasForward:
-            self.assertEqual(forward.tranForward(inPoint),
-                             inverse.tranInverse(inPoint), msg=msg)
-            self.assertEqual(frameSet.tranForward(rawInPoint),
-                             invFrameSet.tranInverse(rawInPoint), msg=msg)
+            self.assertEqual(forward.applyForward(inPoint),
+                             inverse.applyInverse(inPoint), msg=msg)
+            self.assertEqual(frameSet.applyForward(rawInPoint),
+                             invFrameSet.applyInverse(rawInPoint), msg=msg)
             # Assertions must work with both lists and numpy arrays
-            assert_array_equal(forward.tranForward(inArray),
-                               inverse.tranInverse(inArray),
+            assert_array_equal(forward.applyForward(inArray),
+                               inverse.applyInverse(inArray),
                                err_msg=msg)
-            assert_array_equal(frameSet.tranForward(rawInArray),
-                               invFrameSet.tranInverse(rawInArray),
+            assert_array_equal(frameSet.applyForward(rawInArray),
+                               invFrameSet.applyInverse(rawInArray),
                                err_msg=msg)
 
         if forward.hasInverse:
-            self.assertEqual(forward.tranInverse(outPoint),
-                             inverse.tranForward(outPoint), msg=msg)
-            self.assertEqual(frameSet.tranInverse(rawOutPoint),
-                             invFrameSet.tranForward(rawOutPoint), msg=msg)
-            assert_array_equal(forward.tranInverse(outArray),
-                               inverse.tranForward(outArray),
+            self.assertEqual(forward.applyInverse(outPoint),
+                             inverse.applyForward(outPoint), msg=msg)
+            self.assertEqual(frameSet.applyInverse(rawOutPoint),
+                             invFrameSet.applyForward(rawOutPoint), msg=msg)
+            assert_array_equal(forward.applyInverse(outArray),
+                               inverse.applyForward(outArray),
                                err_msg=msg)
-            assert_array_equal(frameSet.tranInverse(rawOutArray),
-                               invFrameSet.tranForward(rawOutArray),
+            assert_array_equal(frameSet.applyInverse(rawOutArray),
+                               invFrameSet.applyForward(rawOutArray),
                                err_msg=msg)
 
     def checkTransformFromMapping(self, fromName, toName):
@@ -922,17 +922,17 @@ def checkThen(self, fromName, midName, toName):
             toEndpoint = transform2.toEndpoint
 
             inPoint = fromEndpoint.pointFromData(self.makeRawPointData(nIn))
-            outPointMerged = transform.tranForward(inPoint)
-            outPointSeparate = transform2.tranForward(
-                transform1.tranForward(inPoint))
+            outPointMerged = transform.applyForward(inPoint)
+            outPointSeparate = transform2.applyForward(
+                transform1.applyForward(inPoint))
             assert_allclose(toEndpoint.dataFromPoint(outPointMerged),
                             toEndpoint.dataFromPoint(outPointSeparate),
                             err_msg=msg)
 
             outPoint = toEndpoint.pointFromData(self.makeRawPointData(nOut))
-            inPointMerged = transform.tranInverse(outPoint)
-            inPointSeparate = transform1.tranInverse(
-                transform2.tranInverse(outPoint))
+            inPointMerged = transform.applyInverse(outPoint)
+            inPointSeparate = transform1.applyInverse(
+                transform2.applyInverse(outPoint))
             assert_allclose(
                 fromEndpoint.dataFromPoint(inPointMerged),
                 fromEndpoint.dataFromPoint(inPointSeparate),
@@ -988,19 +988,19 @@ def checkPersistence(self, transform):
             nPoints = 7  # arbitrary
             rawInArray = self.makeRawArrayData(nPoints, nIn)
             inArray = fromEndpoint.arrayFromData(rawInArray)
-            outArray = transform.tranForward(inArray)
+            outArray = transform.applyForward(inArray)
             outData = toEndpoint.dataFromArray(outArray)
-            outArrayRoundTrip = transformRoundTrip.tranForward(inArray)
+            outArrayRoundTrip = transformRoundTrip.applyForward(inArray)
             outDataRoundTrip = toEndpoint.dataFromArray(outArrayRoundTrip)
             assert_allclose(outData, outDataRoundTrip)
 
         if frameSet.hasInverse:
             nPoints = 7  # arbitrary
             rawOutArray = self.makeRawArrayData(nPoints, nOut)
             outArray = toEndpoint.arrayFromData(rawOutArray)
-            inArray = transform.tranInverse(outArray)
+            inArray = transform.applyInverse(outArray)
             inData = fromEndpoint.dataFromArray(inArray)
-            inArrayRoundTrip = transformRoundTrip.tranInverse(outArray)
+            inArrayRoundTrip = transformRoundTrip.applyInverse(outArray)
             inDataRoundTrip = fromEndpoint.dataFromArray(inArrayRoundTrip)
             assert_allclose(inData, inDataRoundTrip)
         # remove the file (if the test passes)

diff --git a/python/lsst/afw/geom/transform/transform.cc b/python/lsst/afw/geom/transform/transform.cc
@@ -90,10 +90,10 @@ void declareTransform(py::module &mod, std::string const &fromName, std::string
     // will not affect the contained FrameSet (since Python ignores constness)
     cls.def("getFrameSet", [](Class const &self) { return self.getFrameSet()->copy(); });
 
-    cls.def("tranForward", (ToArray (Class::*)(FromArray const &) const) & Class::tranForward, "array"_a);
-    cls.def("tranForward", (ToPoint (Class::*)(FromPoint const &) const) & Class::tranForward, "point"_a);
-    cls.def("tranInverse", (FromArray (Class::*)(ToArray const &) const) & Class::tranInverse, "array"_a);
-    cls.def("tranInverse", (FromPoint (Class::*)(ToPoint const &) const) & Class::tranInverse, "point"_a);
+    cls.def("applyForward", (ToArray (Class::*)(FromArray const &) const) & Class::applyForward, "array"_a);
+    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("getInverse", &Class::getInverse);
     /* Need some extra handling of ndarray return type in Python to prevent dimensions
      * of length 1 from being deleted */

diff --git a/src/geom/SkyWcs.cc b/src/geom/SkyWcs.cc
@@ -76,7 +76,7 @@ Angle SkyWcs::getPixelScale(Point2D const& pixel) const {
     pixVec.push_back(pixel + Extent2D(0.5, -0.5));  // lower right corner
     pixVec.push_back(pixel + Extent2D(-0.5, 0.5));  // upper left corner
 
-    auto skyVec = tranForward(pixVec);
+    auto skyVec = applyForward(pixVec);
 
     // Work in 3-space to avoid RA wrapping and pole issues.
     auto skyLL = skyVec[0].getVector();
@@ -97,7 +97,7 @@ Angle SkyWcs::getPixelScale(Point2D const& pixel) const {
 
 Angle SkyWcs::getPixelScale() const { return getPixelScale(getPixelOrigin()); }
 
-Point2D SkyWcs::getPixelOrigin() const { return this->tranInverse(getSkyOrigin()); }
+Point2D SkyWcs::getPixelOrigin() const { return this->applyInverse(getSkyOrigin()); }
 
 SpherePoint SkyWcs::getSkyOrigin() const {
     // CRVAL is stored as the SkyRef property of the sky frame (the current frame of the SkyWcs)
@@ -121,7 +121,7 @@ Eigen::Matrix2d SkyWcs::getCdMatrix(Point2D const& pixel) const {
 Eigen::Matrix2d SkyWcs::getCdMatrix() const { return getCdMatrix(getPixelOrigin()); }
 
 SkyWcs SkyWcs::getTanWcs(Point2D const& pixel) const {
-    auto const crval = tranForward(pixel);
+    auto const crval = applyForward(pixel);
     auto const cdMatrix = getCdMatrix(pixel);
     return SkyWcs(pixel, crval, cdMatrix);
 }
@@ -199,15 +199,15 @@ SkyWcs SkyWcs::copyAtShiftedPixelOrigin(Extent2D const& shift) const {
 }
 
 std::pair<Angle, Angle> SkyWcs::pixelToSky(double x, double y) const {
-    auto sky = tranForward(Point2D(x, y));
+    auto sky = applyForward(Point2D(x, y));
     return std::pair<Angle, Angle>(sky[0], sky[1]);
 }
 
 /**
 Compute the pixel position from the sky position
 */
 std::pair<double, double> SkyWcs::skyToPixel(Angle const& ra, Angle const& dec) const {
-    auto pixel = tranInverse(SpherePoint(ra, dec));
+    auto pixel = applyInverse(SpherePoint(ra, dec));
     return std::pair<double, double>(pixel[0], pixel[1]);
 };
 

diff --git a/src/geom/Transform.cc b/src/geom/Transform.cc
@@ -77,34 +77,34 @@ Transform<FromEndpoint, ToEndpoint>::Transform(std::shared_ptr<ast::FrameSet> &&
 }
 
 template <class FromEndpoint, class ToEndpoint>
-typename ToEndpoint::Point Transform<FromEndpoint, ToEndpoint>::tranForward(
+typename ToEndpoint::Point Transform<FromEndpoint, ToEndpoint>::applyForward(
         typename FromEndpoint::Point const &point) const {
     auto const rawFromData = _fromEndpoint.dataFromPoint(point);
-    auto rawToData = _frameSet->tranForward(rawFromData);
+    auto rawToData = _frameSet->applyForward(rawFromData);
     return _toEndpoint.pointFromData(rawToData);
 }
 
 template <class FromEndpoint, class ToEndpoint>
-typename ToEndpoint::Array Transform<FromEndpoint, ToEndpoint>::tranForward(
+typename ToEndpoint::Array Transform<FromEndpoint, ToEndpoint>::applyForward(
         typename FromEndpoint::Array const &array) const {
     auto const rawFromData = _fromEndpoint.dataFromArray(array);
-    auto rawToData = _frameSet->tranForward(rawFromData);
+    auto rawToData = _frameSet->applyForward(rawFromData);
     return _toEndpoint.arrayFromData(rawToData);
 }
 
 template <class FromEndpoint, class ToEndpoint>
-typename FromEndpoint::Point Transform<FromEndpoint, ToEndpoint>::tranInverse(
+typename FromEndpoint::Point Transform<FromEndpoint, ToEndpoint>::applyInverse(
         typename ToEndpoint::Point const &point) const {
     auto const rawFromData = _toEndpoint.dataFromPoint(point);
-    auto rawToData = _frameSet->tranInverse(rawFromData);
+    auto rawToData = _frameSet->applyInverse(rawFromData);
     return _fromEndpoint.pointFromData(rawToData);
 }
 
 template <class FromEndpoint, class ToEndpoint>
-typename FromEndpoint::Array Transform<FromEndpoint, ToEndpoint>::tranInverse(
+typename FromEndpoint::Array Transform<FromEndpoint, ToEndpoint>::applyInverse(
         typename ToEndpoint::Array const &array) const {
     auto const rawFromData = _toEndpoint.dataFromArray(array);
-    auto rawToData = _frameSet->tranInverse(rawFromData);
+    auto rawToData = _frameSet->applyInverse(rawFromData);
     return _fromEndpoint.arrayFromData(rawToData);
 }