Use properties for Endpoint and Transform

Instead of getters use properties to read the number of axes
in an Endpoint and the "from" and "to" endpoints of a Transform

python/lsst/afw/geom/endpoint.cc

@@ -122,7 +122,7 @@ void declareBaseEndpoint(py::module& mod, std::string const& suffix) {
 
     py::class_<Class, std::shared_ptr<Class>> cls(mod, pyClassName.c_str());
 
-    cls.def("getNAxes", &Class::getNAxes);
+    cls.def_property_readonly("nAxes", &Class::getNAxes);
     addDataConverters(cls);
     addMakeFrame(cls);
     cls.def("normalizeFrame", &Class::normalizeFrame);

python/lsst/afw/geom/python/transform.py

@@ -48,8 +48,8 @@
 def getJacobian(self, x):
     # Force 2D matrix over numpy's protests
     matrix = self._getJacobian(x)
-    matrix.shape = (self.getToEndpoint().getNAxes(),
-                    self.getFromEndpoint().getNAxes())
+    matrix.shape = (self.toEndpoint.nAxes,
+                    self.fromEndpoint.nAxes)
     return matrix
 
 
@@ -58,7 +58,7 @@ def of(self, first):
 
     The result of B.of(A) is C(x) = B(A(x))
     """
-    if first.getToEndpoint() == self.getFromEndpoint():
+    if first.toEndpoint == self.fromEndpoint:
         return self._of(first)
     else:
         raise lsst.pex.exceptions.InvalidParameterError(

python/lsst/afw/geom/testUtils.py

@@ -502,14 +502,14 @@ def checkTransformation(self, transform, mapping, msg=""):
         msg : `str`
             Error message suffix describing test parameters
         """
-        fromEndpoint = transform.getFromEndpoint()
-        toEndpoint = transform.getToEndpoint()
+        fromEndpoint = transform.fromEndpoint
+        toEndpoint = transform.toEndpoint
         frameSet = transform.getFrameSet()
 
         nIn = mapping.nIn
         nOut = mapping.nOut
-        self.assertEqual(nIn, fromEndpoint.getNAxes(), msg=msg)
-        self.assertEqual(nOut, toEndpoint.getNAxes(), msg=msg)
+        self.assertEqual(nIn, fromEndpoint.nAxes, msg=msg)
+        self.assertEqual(nOut, toEndpoint.nAxes, msg=msg)
 
         # forward transformation of one point
         rawInPoint = self.makeRawPointData(nIn)
@@ -521,7 +521,7 @@ def checkTransformation(self, transform, mapping, msg=""):
         inArray = fromEndpoint.arrayFromData(rawInArray)
 
         if mapping.hasForward:
-            self.assertTrue(transform.hasForward())
+            self.assertTrue(transform.hasForward)
             outPoint = transform.tranForward(inPoint)
             rawOutPoint = toEndpoint.dataFromPoint(outPoint)
             assert_allclose(rawOutPoint, mapping.tranForward(rawInPoint), err_msg=msg)
@@ -538,10 +538,10 @@ def checkTransformation(self, transform, mapping, msg=""):
             rawOutArray = self.makeRawArrayData(nPoints, nOut)
             outArray = toEndpoint.arrayFromData(rawOutArray)
 
-            self.assertFalse(transform.hasForward())
+            self.assertFalse(transform.hasForward)
 
         if mapping.hasInverse:
-            self.assertTrue(transform.hasInverse())
+            self.assertTrue(transform.hasInverse)
             # inverse transformation of one point;
             # remember that the inverse need not give the original values
             # (see the description of the `mapping` parameter)
@@ -558,7 +558,7 @@ def checkTransformation(self, transform, mapping, msg=""):
             self.assertFloatsAlmostEqual(rawInverseArray, mapping.tranInverse(rawOutArray), msg=msg)
             self.assertFloatsAlmostEqual(rawInverseArray, frameSet.tranInverse(rawOutArray), msg=msg)
         else:
-            self.assertFalse(transform.hasInverse())
+            self.assertFalse(transform.hasInverse)
 
     def checkInverseTransformation(self, forward, inverse, msg=""):
         """Check that two Transforms are each others' inverses.
@@ -572,35 +572,35 @@ def checkInverseTransformation(self, forward, inverse, msg=""):
         msg : `str`
             error message suffix describing test parameters
         """
-        fromEndpoint = forward.getFromEndpoint()
-        toEndpoint = forward.getToEndpoint()
+        fromEndpoint = forward.fromEndpoint
+        toEndpoint = forward.toEndpoint
         frameSet = forward.getFrameSet()
         invFrameSet = inverse.getFrameSet()
 
         # properties
-        self.assertEqual(forward.getFromEndpoint(),
-                         inverse.getToEndpoint(), msg=msg)
-        self.assertEqual(forward.getToEndpoint(),
-                         inverse.getFromEndpoint(), msg=msg)
-        self.assertEqual(forward.hasForward(), inverse.hasInverse(), msg=msg)
-        self.assertEqual(forward.hasInverse(), inverse.hasForward(), msg=msg)
+        self.assertEqual(forward.fromEndpoint,
+                         inverse.toEndpoint, msg=msg)
+        self.assertEqual(forward.toEndpoint,
+                         inverse.fromEndpoint, msg=msg)
+        self.assertEqual(forward.hasForward, inverse.hasInverse, msg=msg)
+        self.assertEqual(forward.hasInverse, inverse.hasForward, msg=msg)
 
         # transformations of one point
         # we don't care about whether the transformation itself is correct
         # (see checkTransformation), so inPoint/outPoint need not be related
-        rawInPoint = self.makeRawPointData(fromEndpoint.getNAxes())
+        rawInPoint = self.makeRawPointData(fromEndpoint.nAxes)
         inPoint = fromEndpoint.pointFromData(rawInPoint)
-        rawOutPoint = self.makeRawPointData(toEndpoint.getNAxes())
+        rawOutPoint = self.makeRawPointData(toEndpoint.nAxes)
         outPoint = toEndpoint.pointFromData(rawOutPoint)
 
         # transformations of arrays of points
         nPoints = 7  # arbitrary
-        rawInArray = self.makeRawArrayData(nPoints, fromEndpoint.getNAxes())
+        rawInArray = self.makeRawArrayData(nPoints, fromEndpoint.nAxes)
         inArray = fromEndpoint.arrayFromData(rawInArray)
-        rawOutArray = self.makeRawArrayData(nPoints, toEndpoint.getNAxes())
+        rawOutArray = self.makeRawArrayData(nPoints, toEndpoint.nAxes)
         outArray = toEndpoint.arrayFromData(rawOutArray)
 
-        if forward.hasForward():
+        if forward.hasForward:
             self.assertEqual(forward.tranForward(inPoint),
                              inverse.tranInverse(inPoint), msg=msg)
             self.assertEqual(frameSet.tranForward(rawInPoint),
@@ -613,7 +613,7 @@ def checkInverseTransformation(self, forward, inverse, msg=""):
                                invFrameSet.tranInverse(rawInArray),
                                err_msg=msg)
 
-        if forward.hasInverse():
+        if forward.hasInverse:
             self.assertEqual(forward.tranInverse(outPoint),
                              inverse.tranForward(outPoint), msg=msg)
             self.assertEqual(frameSet.tranInverse(rawOutPoint),
@@ -871,7 +871,7 @@ def checkGetJacobian(self, fromName, toName):
             msg = "{}, nIn={}, nOut={}".format(baseMsg, nIn, nOut)
             polyMap = makeForwardPolyMap(nIn, nOut)
             transform = TransformClass(polyMap)
-            fromEndpoint = transform.getFromEndpoint()
+            fromEndpoint = transform.fromEndpoint
 
             # Test multiple points to ensure correct functional form
             rawInPoint = self.makeRawPointData(nIn)
@@ -918,8 +918,8 @@ def checkOf(self, fromName, midName, toName):
             transform2 = TransformClass2(polyMap)
             transform = transform2.of(transform1)
 
-            fromEndpoint = transform1.getFromEndpoint()
-            toEndpoint = transform2.getToEndpoint()
+            fromEndpoint = transform1.fromEndpoint
+            toEndpoint = transform2.toEndpoint
 
             inPoint = fromEndpoint.pointFromData(self.makeRawPointData(nIn))
             outPointMerged = transform.tranForward(inPoint)
@@ -978,8 +978,8 @@ def checkPersistence(self, transform):
         self.assertEqual(transform.getFrameSet().show(),
                          transformRoundTrip.getFrameSet().show())
 
-        fromEndpoint = transform.getFromEndpoint()
-        toEndpoint = transform.getToEndpoint()
+        fromEndpoint = transform.fromEndpoint
+        toEndpoint = transform.toEndpoint
         frameSet = transform.getFrameSet()
         nIn = frameSet.nIn
         nOut = frameSet.nOut

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

@@ -81,14 +81,14 @@ void declareTransform(py::module &mod, std::string const &fromName, std::string
     cls.def(py::init<ast::FrameSet const &, bool>(), "frameSet"_a, "simplify"_a = true);
     cls.def(py::init<ast::Mapping const &, bool>(), "mapping"_a, "simplify"_a = true);
 
-    cls.def("hasForward", &Class::hasForward);
-    cls.def("hasInverse", &Class::hasInverse);
+    cls.def_property_readonly("hasForward", &Class::hasForward);
+    cls.def_property_readonly("hasInverse", &Class::hasInverse);
+    cls.def_property_readonly("fromEndpoint", &Class::getFromEndpoint);
+    cls.def_property_readonly("toEndpoint", &Class::getToEndpoint);
 
-    cls.def("getFromEndpoint", &Class::getFromEndpoint);
     // Return a copy of the contained FrameSet in order to assure changing the returned FrameSet
     // will not affect the contained FrameSet (since Python ignores constness)
     cls.def("getFrameSet", [](Class const &self) { return self.getFrameSet()->copy(); });
-    cls.def("getToEndpoint", &Class::getToEndpoint);
 
     cls.def("tranForward", (ToArray (Class::*)(FromArray const &) const) & Class::tranForward, "array"_a);
     cls.def("tranForward", (ToPoint (Class::*)(FromPoint const &) const) & Class::tranForward, "point"_a);

tests/test_endpoint.py

@@ -109,7 +109,7 @@ def checkEndpointBasics(self, endpoint, pointType, nAxes):
         baseMsg = "endpoint={}, pointType={}, nAxes={}".format(
             endpoint, pointType, nAxes)
 
-        self.assertEqual(endpoint.getNAxes(), nAxes, msg=baseMsg)
+        self.assertEqual(endpoint.nAxes, nAxes, msg=baseMsg)
 
         # generate enough points to be interesting, but no need to overdo it
         nPoints = 4

tests/test_transform.py

@@ -73,8 +73,8 @@ def testOfChaining(self):
         merged1 = transform3.of(transform2).of(transform1)
         merged2 = transform3.of(transform2.of(transform1))
 
-        fromEndpoint = transform1.getFromEndpoint()
-        toEndpoint = transform3.getToEndpoint()
+        fromEndpoint = transform1.fromEndpoint
+        toEndpoint = transform3.toEndpoint
 
         inPoint = fromEndpoint.pointFromData(self.makeRawPointData(2))
         assert_allclose(toEndpoint.dataFromPoint(merged1.tranForward(inPoint)),