pybind11.h File Reference

#include <pybind11/pybind11.h>

Go to the source code of this file.

Functions
void	bind_centroid (py::module &m)
void	bind_coordinatesystem (py::module &m)
void	bind_ellipse (py::module &m)
void	bind_gaussian (py::module &m)
void	bind_image (py::module &m)
void	bind_object (py::module &m)

Function Documentation

bind_centroid()

void bind_centroid

(

py::module &

m

)

Definition at line 40 of file centroid.cc.

                                {
    auto _c = py::class_<gauss2d::CentroidData, std::shared_ptr<gauss2d::CentroidData>>(m, "CentroidData");
    py::class_<gauss2d::CentroidValues, std::shared_ptr<gauss2d::CentroidValues>, gauss2d::CentroidData>(
            m, "CentroidValues")
            // Note: These can't be shared_ptrs
            .def(py::init<double, double>(), "x"_a = 0, "y"_a = 0)
            .def_property("x", &gauss2d::CentroidValues::get_x, &gauss2d::CentroidValues::set_x)
            .def_property("y", &gauss2d::CentroidValues::get_y, &gauss2d::CentroidValues::set_y)
            .def_property("xy", &gauss2d::CentroidValues::get_xy, &gauss2d::CentroidValues::set_xy)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::CentroidValues &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::CentroidValues::str);
    py::class_<gauss2d::Centroid, std::shared_ptr<gauss2d::Centroid>>(m, "Centroid")
            .def(py::init<std::shared_ptr<gauss2d::CentroidData>>(), "data"_a)
            .def(py::init<double, double>(), "x"_a = 0, "y"_a = 0)
            .def_property("x", &gauss2d::Centroid::get_x, &gauss2d::Centroid::set_x)
            .def_property("y", &gauss2d::Centroid::get_y, &gauss2d::Centroid::set_y)
            .def_property("xy", &gauss2d::Centroid::get_xy, &gauss2d::Centroid::set_xy)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::Centroid &self) { return self.repr(true, self.PY_NAMESPACE_SEPARATOR); })
            .def("__str__", &gauss2d::Centroid::str);
}

bind_coordinatesystem()

void bind_coordinatesystem

(

py::module &

m

)

Definition at line 36 of file coordinatesystem.cc.

                                        {
    py::class_<gauss2d::CoordinateSystem, std::shared_ptr<gauss2d::CoordinateSystem>>(m, "CoordinateSystem")
            .def(py::init<double, double, double, double>(), "dx1"_a = 1., "dy2"_a = 1., "x_min"_a = 0.,
                 "y_min"_a = 0.)
            .def_property_readonly("dx1", &gauss2d::CoordinateSystem::get_dx1)
            .def_property_readonly("dy2", &gauss2d::CoordinateSystem::get_dy2)
            .def_property_readonly("x_min", &gauss2d::CoordinateSystem::get_x_min)
            .def_property_readonly("y_min", &gauss2d::CoordinateSystem::get_y_min)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::CoordinateSystem &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::CoordinateSystem::str);
}

bind_ellipse()

void bind_ellipse

(

py::module &

m

)

Definition at line 40 of file ellipse.cc.

                               {
    py::class_<gauss2d::Covariance, std::shared_ptr<gauss2d::Covariance>>(m, "Covariance")
            .def(py::init<double, double, double>(), "sigma_x_sq"_a = 0, "sigma_y_sq"_a = 0, "cov_xy"_a = 0)
            .def(py::init<gauss2d::Ellipse &>())
            .def("convolve", &gauss2d::Covariance::convolve)
            .def("make_convolution", &gauss2d::Covariance::make_convolution)
            .def("set",
                 static_cast<void (gauss2d::Covariance::*)(double, double, double)>(
                         &gauss2d::Covariance::set),
                 "sigma_x_sq"_a = 0, "sigma_y_sq"_a = 0, "cov_xy"_a = 0)
            .def("set", static_cast<void (gauss2d::Covariance::*)(const gauss2d::Ellipse &)>(
                                &gauss2d::Covariance::set))
            .def_property("sigma_x_sq", &gauss2d::Covariance::get_sigma_x_sq,
                          &gauss2d::Covariance::set_sigma_x_sq)
            .def_property("sigma_y_sq", &gauss2d::Covariance::get_sigma_y_sq,
                          &gauss2d::Covariance::set_sigma_y_sq)
            .def_property("cov_xy", &gauss2d::Covariance::get_cov_xy, &gauss2d::Covariance::set_cov_xy)
            .def_property("xyc", &gauss2d::Covariance::get_xyc, &gauss2d::Covariance::set_xyc)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::Covariance &self) { return self.repr(true, self.PY_NAMESPACE_SEPARATOR); })
            .def("__str__", &gauss2d::Covariance::str);
    auto _e = py::class_<gauss2d::EllipseData, std::shared_ptr<gauss2d::EllipseData>>(m, "EllipseData");
    py::class_<gauss2d::EllipseValues, std::shared_ptr<gauss2d::EllipseValues>, gauss2d::EllipseData>(
            m, "EllipseValues")
            .def(py::init<double, double, double>(), "sigma_x"_a = 0, "sigma_y"_a = 0, "rho"_a = 0)
            .def("set", &gauss2d::EllipseValues::set, "sigma_x"_a, "sigma_y"_a, "rho"_a)
            .def("set_h", &gauss2d::EllipseValues::set_h, "hwhm_x"_a, "hwhm_y"_a, "rho"_a)
            .def_property("rho", &gauss2d::EllipseValues::get_rho, &gauss2d::EllipseValues::set_rho)
            .def_property("hwhm_x", &gauss2d::EllipseValues::get_hwhm_x, &gauss2d::EllipseValues::set_hwhm_x)
            .def_property("hwhm_y", &gauss2d::EllipseValues::get_hwhm_y, &gauss2d::EllipseValues::set_hwhm_y)
            .def_property("sigma_x", &gauss2d::EllipseValues::get_sigma_x,
                          &gauss2d::EllipseValues::set_sigma_x)
            .def_property("sigma_y", &gauss2d::EllipseValues::get_sigma_y,
                          &gauss2d::EllipseValues::set_sigma_y)
            .def_property("hxyr", &gauss2d::EllipseValues::get_hxyr, &gauss2d::EllipseValues::set_hxyr)
            .def_property("xyr", &gauss2d::EllipseValues::get_xyr, &gauss2d::EllipseValues::set_xyr)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::EllipseValues &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::EllipseValues::str);
    py::class_<gauss2d::Ellipse, std::shared_ptr<gauss2d::Ellipse>>(m, "Ellipse")
            .def(py::init<std::shared_ptr<gauss2d::EllipseData>>(), "data"_a)
            .def(py::init<gauss2d::Covariance &>())
            .def(py::init<gauss2d::EllipseMajor &>())
            .def(py::init<double, double, double>(), "sigma_x"_a = 0, "sigma_y"_a = 0, "rho"_a = 0)
            .def_static("check", &gauss2d::Ellipse::check)
            .def("convolve", &gauss2d::Ellipse::convolve)
            .def("get_cov_xy", &gauss2d::Ellipse::get_cov_xy)
            .def("get_radius_trace", &gauss2d::Ellipse::get_radius_trace)
            .def("make_convolution", &gauss2d::Ellipse::make_convolution)
            .def("set",
                 static_cast<void (gauss2d::Ellipse::*)(double, double, double)>(&gauss2d::Ellipse::set),
                 "sigma_x"_a, "sigma_y"_a, "rho"_a)
            .def("set",
                 static_cast<void (gauss2d::Ellipse::*)(const gauss2d::Covariance &)>(&gauss2d::Ellipse::set),
                 "ellipse"_a)
            .def("set",
                 static_cast<void (gauss2d::Ellipse::*)(const gauss2d::EllipseMajor &)>(
                         &gauss2d::Ellipse::set),
                 "ellipse_major"_a)
            .def("set_h", &gauss2d::Ellipse::set_h, "hwhm_x"_a = 0, "hwhm_y"_a = 0, "rho"_a = 0)
            .def_property("rho", &gauss2d::Ellipse::get_rho, &gauss2d::Ellipse::set_rho)
            .def_property("hwhm_x", &gauss2d::Ellipse::get_hwhm_x, &gauss2d::Ellipse::set_hwhm_x)
            .def_property("hwhm_y", &gauss2d::Ellipse::get_hwhm_y, &gauss2d::Ellipse::set_hwhm_y)
            .def_property("sigma_x", &gauss2d::Ellipse::get_sigma_x, &gauss2d::Ellipse::set_sigma_x)
            .def_property("sigma_y", &gauss2d::Ellipse::get_sigma_y, &gauss2d::Ellipse::set_sigma_y)
            .def_property("hxyr", &gauss2d::Ellipse::get_hxyr, &gauss2d::Ellipse::set_hxyr)
            .def_property("xyr", &gauss2d::Ellipse::get_xyr, &gauss2d::Ellipse::set_xyr)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::Ellipse &self) { return self.repr(true, self.PY_NAMESPACE_SEPARATOR); })
            .def("__str__", &gauss2d::Ellipse::str);
    py::class_<gauss2d::EllipseMajor, std::shared_ptr<gauss2d::EllipseMajor>>(m, "EllipseMajor")
            .def(py::init<gauss2d::Covariance &, bool>(), "covariance"_a, "degrees"_a = false)
            .def(py::init<gauss2d::Ellipse &, bool>(), "ellipse"_a, "degrees"_a = false)
            .def(py::init<double, double, double, bool>(), "r_major"_a = 0, "axrat"_a = 1, "angle"_a = 0,
                 "degrees"_a = false)
            .def_static("check", &gauss2d::EllipseMajor::check)
            .def("get_angle_degrees", &gauss2d::EllipseMajor::get_angle_degrees)
            .def("get_angle_radians", &gauss2d::EllipseMajor::get_angle_radians)
            .def_property("r_major", &gauss2d::EllipseMajor::get_r_major, &gauss2d::EllipseMajor::set_r_major)
            .def_property("axrat", &gauss2d::EllipseMajor::get_axrat, &gauss2d::EllipseMajor::set_axrat)
            .def_property("angle", &gauss2d::EllipseMajor::get_angle, &gauss2d::EllipseMajor::set_angle)
            .def_property("degrees", &gauss2d::EllipseMajor::is_degrees, &gauss2d::EllipseMajor::set_degrees)
            .def_property("rqa", &gauss2d::EllipseMajor::get_rqa, &gauss2d::EllipseMajor::set_rqa)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::EllipseMajor &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::EllipseMajor::str);
}

bind_gaussian()

void bind_gaussian

(

py::module &

m

)

Definition at line 42 of file gaussian.cc.

                                {
    m.doc() = "Gauss2D Gaussian Python bindings";
 
    m.attr("M_HWHM_SIGMA") = py::float_(gauss2d::M_HWHM_SIGMA);
    m.attr("M_SIGMA_HWHM") = py::float_(gauss2d::M_SIGMA_HWHM);
 
    auto _g = py::class_<gauss2d::GaussianIntegral, std::shared_ptr<gauss2d::GaussianIntegral>>(
            m, "GaussianIntegral");
    py::class_<gauss2d::GaussianIntegralValue, gauss2d::GaussianIntegral,
               std::shared_ptr<gauss2d::GaussianIntegralValue>>(m, "GaussianIntegralValue")
            .def(py::init<double>(), "value"_a = 1)
            .def_property("value", &gauss2d::GaussianIntegralValue::get_value,
                          &gauss2d::GaussianIntegralValue::set_value)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::GaussianIntegralValue &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::GaussianIntegralValue::str);
 
    py::class_<gauss2d::Gaussian, std::shared_ptr<gauss2d::Gaussian>>(m, "Gaussian")
            .def(py::init<std::shared_ptr<gauss2d::Centroid>, std::shared_ptr<gauss2d::Ellipse>,
                          std::shared_ptr<gauss2d::GaussianIntegral>>(),
                 "centroid"_a = nullptr, "ellipse"_a = nullptr, "integral"_a = nullptr)
            .def_property_readonly("centroid", &gauss2d::Gaussian::get_centroid)
            .def_property_readonly("ellipse", &gauss2d::Gaussian::get_ellipse)
            .def_property_readonly("integral", &gauss2d::Gaussian::get_integral)
            .def_property("const_normal", &gauss2d::Gaussian::get_const_normal,
                          &gauss2d::Gaussian::set_const_normal)
            .def_property("integral_value", &gauss2d::Gaussian::get_integral_value,
                          &gauss2d::Gaussian::set_integral_value)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::Gaussian &self) { return self.repr(true, self.PY_NAMESPACE_SEPARATOR); })
            .def("__str__", &gauss2d::Gaussian::str);
    py::class_<gauss2d::Gaussians, std::shared_ptr<gauss2d::Gaussians>>(m, "Gaussians")
            .def(py::init<std::optional<const gauss2d::Gaussians::Data>>(), "gaussians"_a)
            .def("at", &gauss2d::Gaussians::at, py::return_value_policy::copy)
            .def_property_readonly("size", &gauss2d::Gaussians::size)
            .def("__getitem__", &gauss2d::Gaussians::at_ptr, py::return_value_policy::copy)
            .def("__len__", &gauss2d::Gaussians::size)
            .def("__repr__",
                 [](const gauss2d::Gaussians &self) { return self.repr(true, self.PY_NAMESPACE_SEPARATOR); })
            .def("__str__", &gauss2d::Gaussians::str);
    py::class_<gauss2d::ConvolvedGaussian, std::shared_ptr<gauss2d::ConvolvedGaussian>>(m,
                                                                                        "ConvolvedGaussian")
            .def(py::init<std::shared_ptr<gauss2d::Gaussian>, std::shared_ptr<gauss2d::Gaussian>>(),
                 "source"_a = nullptr, "kernel"_a = nullptr)
            .def_property_readonly("kernel", &gauss2d::ConvolvedGaussian::get_kernel)
            .def_property_readonly("source", &gauss2d::ConvolvedGaussian::get_source)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def("__repr__",
                 [](const gauss2d::ConvolvedGaussian &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::ConvolvedGaussian::str);
    py::class_<gauss2d::ConvolvedGaussians, std::shared_ptr<gauss2d::ConvolvedGaussians>>(
            m, "ConvolvedGaussians")
            .def(py::init<std::optional<const gauss2d::ConvolvedGaussians::Data>>(), "convolvedbgaussians"_a)
            .def("at", &gauss2d::ConvolvedGaussians::at_ptr, py::return_value_policy::copy)
            .def_property_readonly("size", &gauss2d::ConvolvedGaussians::size)
            .def("__getitem__", &gauss2d::ConvolvedGaussians::at_ptr, py::return_value_policy::copy)
            .def("__len__", &gauss2d::ConvolvedGaussians::size)
            .def("__repr__",
                 [](const gauss2d::ConvolvedGaussians &self) {
                     return self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                 })
            .def("__str__", &gauss2d::ConvolvedGaussians::str);
}

bind_image()

void bind_image

(

py::module &

m

)

Definition at line 42 of file image.cc.

                             {
    g2d::python::declare_image<bool>(m, "B");
    g2d::python::declare_image<float>(m, "F");
    g2d::python::declare_image<double>(m, "D");
    g2d::python::declare_image<int>(m, "I");
    g2d::python::declare_image<unsigned int>(m, "U");
    g2d::python::declare_image<size_t>(m, "S");
    g2d::python::declare_image_array<bool>(m, "B");
    g2d::python::declare_image_array<float>(m, "F");
    g2d::python::declare_image_array<double>(m, "D");
    g2d::python::declare_image_array<int>(m, "I");
    g2d::python::declare_image_array<unsigned int>(m, "U");
    g2d::python::declare_image_array<size_t>(m, "S");
    g2d::python::declare_evaluator<float>(m, "F");
    g2d::python::declare_evaluator<double>(m, "D");
    g2d::python::declare_maker<float, g2d::python::Image<float>, g2d::python::Image<size_t>>(m, "F");
    g2d::python::declare_maker<double, g2d::python::Image<double>, g2d::python::Image<size_t>>(m, "D");
}

bind_object()

void bind_object

(

py::module &

m

)

Definition at line 38 of file object.cc.

                              {
    py::class_<gauss2d::Object, std::shared_ptr<gauss2d::Object>>(m, "Object");
}