DM-37720: use pybind wrappers, merge into one pybind shared lib

python/lsst/jointcal/SConscript

@@ -1,20 +1,3 @@
 # -*- python -*-
 from lsst.sconsUtils import scripts
-scripts.BasicSConscript.pybind11(
-    ['associations',
-     'astrometryMappings',
-     'astrometryModels',
-     'astrometryTransform',
-     'ccdImage',
-     'chi2',
-     'fitter',
-     'frame',
-     'jointcalControl',
-     'photometryMappings',
-     'photometryModels',
-     'photometryTransform',
-     'projectionHandler',
-     'star'
-    ],
-    addUnderscore=False,
-)
+scripts.BasicSConscript.python(["_jointcalLib"])

python/lsst/jointcal/__init__.py

@@ -21,18 +21,7 @@
 
 import pkgutil
 import lsstimport
-from .associations import *
-from .astrometryMappings import *
-from .astrometryModels import *
-from .ccdImage import *
-from .chi2 import *
-from .fitter import *
-from .astrometryTransform import *
+from ._jointcalLib import *
 from .jointcal import *
-from .jointcalControl import *
-from .photometryMappings import *
-from .photometryModels import *
-from .photometryTransform import *
-from .projectionHandler import *
 from .version import *
 __path__ = pkgutil.extend_path(__path__, __name__)

python/lsst/jointcal/_jointcalLib.cc

@@ -0,0 +1,68 @@
+/*
+ * This file is part of jointcal.
+ *
+ * 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/>.
+ */
+
+#include "pybind11/pybind11.h"
+#include "lsst/cpputils/python.h"
+
+namespace lsst {
+namespace jointcal {
+
+using lsst::cpputils::python::WrapperCollection;
+void wrapAssociations(WrapperCollection &wrappers);
+void wrapAstrometryMappings(WrapperCollection &wrappers);
+void wrapAstrometryModels(WrapperCollection &wrappers);
+void wrapAstrometryTransform(WrapperCollection &wrappers);
+void wrapCcdImage(WrapperCollection &wrappers);
+void wrapChi2(WrapperCollection &wrappers);
+void wrapFitter(WrapperCollection &wrappers);
+void wrapFrame(WrapperCollection &wrappers);
+void wrapJointcalControl(WrapperCollection &wrappers);
+void wrapPhotometryMappings(WrapperCollection &wrappers);
+void wrapPhotometryModels(WrapperCollection &wrappers);
+void wrapPhotometryTransform(WrapperCollection &wrappers);
+void wrapProjectionHandler(WrapperCollection &wrappers);
+void wrapStar(WrapperCollection &wrappers);
+
+PYBIND11_MODULE(_jointcalLib, mod) {
+    lsst::cpputils::python::WrapperCollection wrappers(mod, "lsst.jointcal");
+    wrappers.addInheritanceDependency("lsst.sphgeom");
+    wrappers.addSignatureDependency("astshim");
+    wrapAssociations(wrappers);
+    wrapAstrometryMappings(wrappers);
+    wrapAstrometryModels(wrappers);
+    wrapAstrometryTransform(wrappers);
+    wrapCcdImage(wrappers);
+    wrapChi2(wrappers);
+    wrapFitter(wrappers);
+    wrapFrame(wrappers);
+    wrapJointcalControl(wrappers);
+    wrapPhotometryMappings(wrappers);
+    wrapPhotometryModels(wrappers);
+    wrapPhotometryTransform(wrappers);
+    wrapProjectionHandler(wrappers);
+    wrapStar(wrappers);
+    wrappers.finish();
+}
+
+}
+}

python/lsst/jointcal/associations.cc

@@ -24,6 +24,7 @@
 
 #include "pybind11/pybind11.h"
 #include "pybind11/stl.h"
+#include "lsst/cpputils/python.h"
 
 #include "lsst/jointcal/Associations.h"
 #include "lsst/jointcal/CcdImage.h"
@@ -36,46 +37,46 @@ namespace lsst {
 namespace jointcal {
 namespace {
 
-void declareAssociations(py::module &mod) {
-    py::class_<Associations, std::shared_ptr<Associations>> cls(mod, "Associations");
-    cls.def(py::init<>());
-    cls.def(py::init<CcdImageList const &, double>(), "imageList"_a, "epoch"_a = 0);
+void declareAssociations(lsst::cpputils::python::WrapperCollection &wrappers) {
+    using PyAssociations = py::class_<Associations, std::shared_ptr<Associations>>;
+    wrappers.wrapType(PyAssociations(wrappers.module, "Associations"), [](auto &mod, auto &cls) {
+        cls.def(py::init<>());
+        cls.def(py::init<CcdImageList const &, double>(), "imageList"_a, "epoch"_a = 0);
 
-    // NOTE: these could go away if the lists they wrap can be accessed directly.
-    cls.def("refStarListSize", &Associations::refStarListSize);
-    cls.def("fittedStarListSize", &Associations::fittedStarListSize);
-    cls.def("associateCatalogs", &Associations::associateCatalogs, "matchCutInArcsec"_a = 0,
-            "useFittedList"_a = false, "enlargeFittedList"_a = true);
-    cls.def("collectRefStars", &Associations::collectRefStars, "refCat"_a, "matchCut"_a, "fluxField"_a,
-            "refCoordinateErr"_a, "rejectBadFluxes"_a = false);
-    cls.def("deprojectFittedStars", &Associations::deprojectFittedStars);
-    cls.def("nCcdImagesValidForFit", &Associations::nCcdImagesValidForFit);
-    cls.def("nFittedStarsWithAssociatedRefStar", &Associations::nFittedStarsWithAssociatedRefStar);
+        // NOTE: these could go away if the lists they wrap can be accessed directly.
+        cls.def("refStarListSize", &Associations::refStarListSize);
+        cls.def("fittedStarListSize", &Associations::fittedStarListSize);
+        cls.def("associateCatalogs", &Associations::associateCatalogs, "matchCutInArcsec"_a = 0,
+                "useFittedList"_a = false, "enlargeFittedList"_a = true);
+        cls.def("collectRefStars", &Associations::collectRefStars, "refCat"_a, "matchCut"_a, "fluxField"_a,
+                "refCoordinateErr"_a, "rejectBadFluxes"_a = false);
+        cls.def("deprojectFittedStars", &Associations::deprojectFittedStars);
+        cls.def("nCcdImagesValidForFit", &Associations::nCcdImagesValidForFit);
+        cls.def("nFittedStarsWithAssociatedRefStar", &Associations::nFittedStarsWithAssociatedRefStar);
 
-    cls.def("createCcdImage", &Associations::createCcdImage);
-    cls.def("addCcdImage", &Associations::addCcdImage);
-    cls.def("prepareFittedStars", &Associations::prepareFittedStars);
-    cls.def("cleanFittedStars", &Associations::cleanFittedStars);
+        cls.def("createCcdImage", &Associations::createCcdImage);
+        cls.def("addCcdImage", &Associations::addCcdImage);
+        cls.def("prepareFittedStars", &Associations::prepareFittedStars);
+        cls.def("cleanFittedStars", &Associations::cleanFittedStars);
 
-    cls.def("getCcdImageList", &Associations::getCcdImageList, py::return_value_policy::reference_internal);
-    cls.def_property_readonly("ccdImageList", &Associations::getCcdImageList,
-                              py::return_value_policy::reference_internal);
+        cls.def("getCcdImageList", &Associations::getCcdImageList, py::return_value_policy::reference_internal);
+        cls.def_property_readonly("ccdImageList", &Associations::getCcdImageList,
+                                  py::return_value_policy::reference_internal);
 
-    cls.def("computeBoundingCircle", &Associations::computeBoundingCircle);
+        cls.def("computeBoundingCircle", &Associations::computeBoundingCircle);
 
-    cls.def("getCommonTangentPoint", &Associations::getCommonTangentPoint);
-    cls.def("setCommonTangentPoint", &Associations::setCommonTangentPoint);
-    cls.def("computeCommonTangentPoint", &Associations::computeCommonTangentPoint);
+        cls.def("getCommonTangentPoint", &Associations::getCommonTangentPoint);
+        cls.def("setCommonTangentPoint", &Associations::setCommonTangentPoint);
+        cls.def("computeCommonTangentPoint", &Associations::computeCommonTangentPoint);
 
-    cls.def("getEpoch", &Associations::getEpoch);
-    cls.def("setEpoch", &Associations::setEpoch);
+        cls.def("getEpoch", &Associations::getEpoch);
+        cls.def("setEpoch", &Associations::setEpoch);
+    });
 }
+}  // namespace
 
-PYBIND11_MODULE(associations, mod) {
-    py::module::import("lsst.jointcal.ccdImage");
-    py::module::import("lsst.sphgeom");
-    declareAssociations(mod);
+void wrapAssociations(lsst::cpputils::python::WrapperCollection &wrappers) {
+    declareAssociations(wrappers);
 }
-}  // namespace
 }  // namespace jointcal
 }  // namespace lsst

python/lsst/jointcal/astrometryMappings.cc

@@ -23,7 +23,7 @@
  */
 
 #include "pybind11/pybind11.h"
-#include "pybind11/eigen.h"
+#include "lsst/cpputils/python.h"
 
 #include "lsst/jointcal/AstrometryTransform.h"
 #include "lsst/jointcal/AstrometryMapping.h"
@@ -36,54 +36,60 @@ namespace lsst {
 namespace jointcal {
 namespace {
 
-void declareAstrometryMapping(py::module &mod) {
-    py::class_<AstrometryMapping, std::shared_ptr<AstrometryMapping>> cls(mod, "AstrometryMapping");
-
-    cls.def("getNpar", &AstrometryMapping::getNpar);
-    cls.def("transformPosAndErrors", [](AstrometryMapping const &self, jointcal::FatPoint &inPos) {
-        jointcal::FatPoint outPos;
-        self.transformPosAndErrors(inPos, outPos);
-        return outPos;
+void declareAstrometryMapping(lsst::cpputils::python::WrapperCollection &wrappers) {
+    using PyAstrometryMapping = py::class_<AstrometryMapping, std::shared_ptr<AstrometryMapping>>;
+    wrappers.wrapType(PyAstrometryMapping(wrappers.module, "AstrometryMapping"), [](auto &mod, auto &cls) {
+        cls.def("getNpar", &AstrometryMapping::getNpar);
+        cls.def("transformPosAndErrors", [](AstrometryMapping const &self, jointcal::FatPoint &inPos) {
+            jointcal::FatPoint outPos;
+            self.transformPosAndErrors(inPos, outPos);
+            return outPos;
+        });
     });
 }
 
-void declareChipVisitAstrometryMapping(py::module &mod) {
-    py::class_<ChipVisitAstrometryMapping, std::shared_ptr<ChipVisitAstrometryMapping>, AstrometryMapping>
-            cls(mod, "ChipVisitAstrometryMapping");
+void declareChipVisitAstrometryMapping(lsst::cpputils::python::WrapperCollection &wrappers) {
+    using PyChipVisitAstrometryMapping =
+            py::class_<ChipVisitAstrometryMapping, std::shared_ptr<ChipVisitAstrometryMapping>, AstrometryMapping>;
 
-    cls.def("getTransform1", &ChipVisitAstrometryMapping::getTransform1,
-            py::return_value_policy::reference_internal);
-    cls.def_property_readonly("transform1", &ChipVisitAstrometryMapping::getTransform1,
-                              py::return_value_policy::reference_internal);
+    wrappers.wrapType(PyChipVisitAstrometryMapping(wrappers.module, "ChipVisitAstrometryMapping"),
+                      [](auto &mod, auto &cls) {
+                          cls.def("getTransform1", &ChipVisitAstrometryMapping::getTransform1,
+                                  py::return_value_policy::reference_internal);
+                          cls.def_property_readonly("transform1", &ChipVisitAstrometryMapping::getTransform1,
+                                                    py::return_value_policy::reference_internal);
 
-    cls.def("getTransform2", &ChipVisitAstrometryMapping::getTransform2,
-            py::return_value_policy::reference_internal);
-    cls.def_property_readonly("transform2", &ChipVisitAstrometryMapping::getTransform2,
-                              py::return_value_policy::reference_internal);
+                          cls.def("getTransform2", &ChipVisitAstrometryMapping::getTransform2,
+                                  py::return_value_policy::reference_internal);
+                          cls.def_property_readonly("transform2", &ChipVisitAstrometryMapping::getTransform2,
+                                                    py::return_value_policy::reference_internal);
+                      });
 }
 
-void declareSimpleAstrometryMapping(py::module &mod) {
-    py::class_<SimpleAstrometryMapping, std::shared_ptr<SimpleAstrometryMapping>, AstrometryMapping> cls(
-            mod, "SimpleAstrometryMapping");
-    cls.def("getToBeFit", &SimpleAstrometryMapping::getToBeFit);
-    cls.def("setToBeFit", &SimpleAstrometryMapping::setToBeFit);
-    cls.def("getTransform", &SimpleAstrometryMapping::getTransform,
-            py::return_value_policy::reference_internal);
+void declareSimpleAstrometryMapping(lsst::cpputils::python::WrapperCollection &wrappers) {
+    using PySimpleAstrometryMapping =
+            py::class_<SimpleAstrometryMapping, std::shared_ptr<SimpleAstrometryMapping>, AstrometryMapping>;
+    wrappers.wrapType(PySimpleAstrometryMapping(wrappers.module, "impleAstrometryMapping"), [](auto &mod, auto &cls) {
+        cls.def("getToBeFit", &SimpleAstrometryMapping::getToBeFit);
+        cls.def("setToBeFit", &SimpleAstrometryMapping::setToBeFit);
+        cls.def("getTransform", &SimpleAstrometryMapping::getTransform,
+                py::return_value_policy::reference_internal);
+    });
 }
 
-void declareSimplePolyMapping(py::module &mod) {
-    py::class_<SimplePolyMapping, std::shared_ptr<SimplePolyMapping>, SimpleAstrometryMapping> cls(
-            mod, "SimplePolyMapping");
-}
+void declareSimplePolyMapping(lsst::cpputils::python::WrapperCollection &wrappers) {
+    using PySimplePolyMapping = py::class_<SimplePolyMapping, std::shared_ptr<SimplePolyMapping>, SimpleAstrometryMapping>;
 
-PYBIND11_MODULE(astrometryMappings, mod) {
-    py::module::import("lsst.jointcal.star");
-    py::module::import("lsst.jointcal.astrometryTransform");
-    declareAstrometryMapping(mod);
-    declareChipVisitAstrometryMapping(mod);
-    declareSimpleAstrometryMapping(mod);
-    declareSimplePolyMapping(mod);
+    wrappers.wrapType(PySimplePolyMapping(wrappers.module, "SimplePolyMapping"), [](auto &mod, auto &cls) {
+    });
 }
 }  // namespace
+
+void wrapAstrometryMappings(lsst::cpputils::python::WrapperCollection &wrappers) {
+    declareAstrometryMapping(wrappers);
+    declareChipVisitAstrometryMapping(wrappers);
+    declareSimpleAstrometryMapping(wrappers);
+    declareSimplePolyMapping(wrappers);
+}
 }  // namespace jointcal
 }  // namespace lsst