Add ostream::operator<< to Transform

and __str__ and __repr__ and test.
lsst · Mar 3, 2017 · 5d8f7d7 · 5d8f7d7
1 parent 3e6c56d
commit 5d8f7d7
Show file tree

Hide file tree

Showing 4 changed files with 57 additions and 17 deletions.
diff --git a/include/lsst/afw/geom/Transform.h b/include/lsst/afw/geom/Transform.h
@@ -141,6 +141,9 @@ class Transform {
     ToEndpoint const _toEndpoint;
 };
 
+template <typename FromEndpoint, typename ToEndpoint>
+std::ostream & operator<<(std::ostream & os, Transform<FromEndpoint, ToEndpoint> const & transform);
+
 }  // geom
 }  // afw
 }  // lsst

diff --git a/python/lsst/afw/geom/transform.cc b/python/lsst/afw/geom/transform.cc
@@ -41,6 +41,15 @@ namespace geom {
 
 namespace {
 
+template<typename Class>
+std::string formatStr(Class const & self, std::string const & pyClassName) {
+    std::ostringstream os;
+    os << pyClassName;
+    auto const frameSet = self.getFrameSet();
+    os << "[" << frameSet->getNin() << "->" << frameSet->getNout() << "]";
+    return os.str();
+}
+
 // Declare Transform<FromEndpoint, ToEndpoint>
 template <typename FromEndpoint, typename ToEndpoint>
 void declareTransform(py::module& mod, std::string const & fromName, std::string const & toName) {
@@ -50,7 +59,9 @@ void declareTransform(py::module& mod, std::string const & fromName, std::string
     using FromPoint = typename FromEndpoint::Point;
     using FromArray = typename FromEndpoint::Array;
 
-    py::class_<Class, std::shared_ptr<Class>> cls(mod, ("TransformFrom" + fromName + "To" + toName).c_str());
+    std::string const pyClassName = "TransformFrom" + fromName + "To" + toName;
+
+    py::class_<Class, std::shared_ptr<Class>> cls(mod, pyClassName.c_str());
 
     cls.def(py::init<ast::Mapping const &, bool>(), "mapping"_a, "simplify"_a=true);
     cls.def(py::init<ast::FrameSet const &, bool>(), "frameSet"_a, "simplify"_a=true);
@@ -63,6 +74,14 @@ void declareTransform(py::module& mod, std::string const & fromName, std::string
     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);
+    /// repr format is lsst.afw.geom.<ClassName>[<nIn>-><nOut>]
+    cls.def("__repr__", [pyClassName](Class const & self) {
+        return "lsst.afw.geom." + formatStr(self, pyClassName);
+    });
+    /// str format is <ClassName>[<nIn>-><nOut>]
+    cls.def("__str__", [pyClassName](Class const & self) {
+        return formatStr(self, pyClassName);
+    });
 }
 
 }  // <anonymous>

diff --git a/src/geom/Transform.cc b/src/geom/Transform.cc
@@ -21,6 +21,7 @@
  */
 
 #include <memory>
+#include <ostream>
 #include <vector>
 
 #include "astshim.h"
@@ -103,23 +104,36 @@ typename FromEndpoint::Array Transform<FromEndpoint, ToEndpoint>::tranInverse(
     return _fromEndpoint.arrayFromData(rawToData);
 }
 
+template <typename FromEndpoint, typename ToEndpoint>
+std::ostream &operator<<(std::ostream &os, Transform<FromEndpoint, ToEndpoint> const &transform) {
+    auto const frameSet = transform.getFrameSet();
+    os << "Transform<" << transform.getFromEndpoint() << ", " << transform.getToEndpoint() << ">"
+       << "[" << frameSet->getNin() << "->" << frameSet->getNout() << "]";
+    return os;
+};
+
+#define INSTANTIATE_TRANSFORM(FromEndpoint, ToEndpoint) \
+    template class Transform<FromEndpoint, ToEndpoint>; \
+    template std::ostream &operator<< <FromEndpoint, ToEndpoint> \
+        (std::ostream &os, Transform<FromEndpoint, ToEndpoint> const &transform);
+
 // explicit instantiations
-template class Transform<GenericEndpoint, GenericEndpoint>;
-template class Transform<GenericEndpoint, Point2Endpoint>;
-template class Transform<GenericEndpoint, Point3Endpoint>;
-template class Transform<GenericEndpoint, SpherePointEndpoint>;
-template class Transform<Point2Endpoint, GenericEndpoint>;
-template class Transform<Point2Endpoint, Point2Endpoint>;
-template class Transform<Point2Endpoint, Point3Endpoint>;
-template class Transform<Point2Endpoint, SpherePointEndpoint>;
-template class Transform<Point3Endpoint, GenericEndpoint>;
-template class Transform<Point3Endpoint, Point2Endpoint>;
-template class Transform<Point3Endpoint, Point3Endpoint>;
-template class Transform<Point3Endpoint, SpherePointEndpoint>;
-template class Transform<SpherePointEndpoint, GenericEndpoint>;
-template class Transform<SpherePointEndpoint, Point2Endpoint>;
-template class Transform<SpherePointEndpoint, Point3Endpoint>;
-template class Transform<SpherePointEndpoint, SpherePointEndpoint>;
+INSTANTIATE_TRANSFORM(GenericEndpoint, GenericEndpoint);
+INSTANTIATE_TRANSFORM(GenericEndpoint, Point2Endpoint);
+INSTANTIATE_TRANSFORM(GenericEndpoint, Point3Endpoint);
+INSTANTIATE_TRANSFORM(GenericEndpoint, SpherePointEndpoint);
+INSTANTIATE_TRANSFORM(Point2Endpoint, GenericEndpoint);
+INSTANTIATE_TRANSFORM(Point2Endpoint, Point2Endpoint);
+INSTANTIATE_TRANSFORM(Point2Endpoint, Point3Endpoint);
+INSTANTIATE_TRANSFORM(Point2Endpoint, SpherePointEndpoint);
+INSTANTIATE_TRANSFORM(Point3Endpoint, GenericEndpoint);
+INSTANTIATE_TRANSFORM(Point3Endpoint, Point2Endpoint);
+INSTANTIATE_TRANSFORM(Point3Endpoint, Point3Endpoint);
+INSTANTIATE_TRANSFORM(Point3Endpoint, SpherePointEndpoint);
+INSTANTIATE_TRANSFORM(SpherePointEndpoint, GenericEndpoint);
+INSTANTIATE_TRANSFORM(SpherePointEndpoint, Point2Endpoint);
+INSTANTIATE_TRANSFORM(SpherePointEndpoint, Point3Endpoint);
+INSTANTIATE_TRANSFORM(SpherePointEndpoint, SpherePointEndpoint);
 
 }  // geom
 }  // afw

diff --git a/tests/test_transform.py b/tests/test_transform.py
@@ -131,6 +131,10 @@ def checkTransform(self, fromName, toName):
                 polyMap = makePolyMap(nIn, nOut)
                 transform = transformClass(polyMap)
 
+                desStr = "{}[{}->{}]".format(transformClassName, nIn, nOut)
+                self.assertEqual("{}".format(transform), desStr)
+                self.assertEqual(repr(transform), "lsst.afw.geom." + desStr)
+
                 fromEndpoint = transform.getFromEndpoint()
                 toEndpoint = transform.getToEndpoint()
                 frameSet = transform.getFrameSet()