lsst::gauss2d::python Namespace Reference

Classes
class	Image
	A Python image using numpy arrrays for storage. More...

Functions
template<typename T >
std::string	replace_type (std::string target, std::string replacement)
template<typename Value , typename Index >
std::string	replace_images_types (std::string target, std::string str_type, std::string_view separator)
	Replace templated Image and index Image type name with Pythonic names.
template<typename T >
void	declare_image (py::module &m, std::string str_type)
template<typename T >
std::string	replace_image_types (std::string target, std::string str_type, std::string_view separator)
	Replace a template Image type name with Pythonic names.
template<typename T >
void	declare_image_array (py::module &m, std::string str_type)
template<typename T >
void	declare_evaluator (py::module &m, std::string str_type)
template<typename T , class Data , class Indices >
void	declare_maker (py::module &m, std::string str_type)

Function Documentation

declare_evaluator()

template<typename T >

void lsst::gauss2d::python::declare_evaluator	(	py::module &	m,
		std::string	str_type )

Definition at line 237 of file image.h.

                                                        {
    using Class = lsst::gauss2d::GaussianEvaluator<T, Image<T>, Image<lsst::gauss2d::idx_type>>;
    std::string pyclass_name = std::string("GaussianEvaluator") + str_type;
    py::class_<Class, std::shared_ptr<Class>>(m, pyclass_name.c_str())
            .def(py::init<const std::shared_ptr<const gauss2d::ConvolvedGaussians>,
                          const std::shared_ptr<const Image<T>>, const std::shared_ptr<const Image<T>>,
                          const std::shared_ptr<Image<T>>, const std::shared_ptr<Image<T>>,
                          const std::shared_ptr<gauss2d::ImageArray<T, Image<T>>>,
                          const std::shared_ptr<const Image<gauss2d::idx_type>>,
                          const std::shared_ptr<const Image<T>>,
                          const std::shared_ptr<const Image<gauss2d::idx_type>>,
                          const std::shared_ptr<const Image<T>>, const std::shared_ptr<const Image<T>>>(),
                 "gaussians"_a, "data"_a = nullptr, "sigma_inv"_a = nullptr, "output"_a = nullptr,
                 "residual"_a = nullptr, "grads"_a = nullptr, "grad_param_map"_a = nullptr,
                 "grad_param_factor"_a = nullptr, "extra_param_map"_a = nullptr,
                 "extra_param_factor"_a = nullptr, "background"_a = nullptr)
            .def("loglike_pixel", &Class::loglike_pixel, "to_add"_a = false)
            .def_property_readonly("n_cols", &Class::get_n_cols)
            .def_property_readonly("n_rows", &Class::get_n_rows)
            .def_property_readonly("size", &Class::get_size)
            .def("__len__", &Class::get_size)
            .def("__repr__",
                 [str_type](const Class &self) {
                     std::string repr = self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                     repr = replace_images_types<T, lsst::gauss2d::idx_type>(repr, str_type,
                                                                             self.PY_NAMESPACE_SEPARATOR);
                     return repr;
                 })
            .def("__str__", [str_type](const Class &self) {
                std::string str = self.str();
                str = replace_images_types<T, lsst::gauss2d::idx_type>(str, str_type,
                                                                       self.CC_NAMESPACE_SEPARATOR);
                return str;
            });
}

declare_image()

template<typename T >

void lsst::gauss2d::python::declare_image	(	py::module &	m,
		std::string	str_type )

Definition at line 157 of file image.h.

                                                    {
    using Class = Image<T>;
    std::string pyclass_name = std::string("Image") + str_type;
    py::class_<Class, std::shared_ptr<Class>>(m, pyclass_name.c_str())
            .def(py::init<size_t, size_t, const T *,
                          const std::shared_ptr<const lsst::gauss2d::CoordinateSystem>>(),
                 "n_rows"_a, "n_cols"_a, "value_init"_a = Class::_value_default_ptr(),
                 "coordsys"_a = gauss2d::COORDS_DEFAULT)
            .def(py::init<py::array_t<T>, const std::shared_ptr<const lsst::gauss2d::CoordinateSystem>>(),
                 "data"_a, "coordsys"_a = gauss2d::COORDS_DEFAULT)
            .def_property_readonly("coordsys", &Class::get_coordsys_ptr_const)
            .def_property_readonly("data", &Class::get_data)
            .def_property_readonly("n_rows", &Class::get_n_rows)
            .def_property_readonly("n_cols", &Class::get_n_cols)
            .def("fill", &Class::fill)
            .def("get_value", &Class::get_value, "row"_a, "col"_a)
            .def("set_value", &Class::set_value, "row"_a, "col"_a, "value"_a)
            .def("get_value_unchecked", &Class::get_value_unchecked, "row"_a, "col"_a)
            .def("set_value_unchecked", &Class::set_value_unchecked, "row"_a, "col"_a, "value"_a)
            .def_property_readonly("size", &Class::size)
            .def_property_readonly("shape", &Class::shape)
            .def(py::self == py::self)
            .def(py::self != py::self)
            .def(py::self += T())
            .def(py::self *= T())
            .def("__repr__",
                 [str_type](const Class &self) {
                     std::string repr = self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                     return replace_type<T>(repr, str_type);
                 })
            .def("__str__", [str_type](const Class &self) {
                std::string str = self.str();
                return replace_type<T>(str, str_type);
            });
}

declare_image_array()

template<typename T >

void lsst::gauss2d::python::declare_image_array	(	py::module &	m,
		std::string	str_type )

Definition at line 214 of file image.h.

                                                          {
    using Class = lsst::gauss2d::ImageArray<T, Image<T>>;
    std::string pyclass_name = std::string("ImageArray") + str_type;
    py::class_<Class, std::shared_ptr<Class>>(m, pyclass_name.c_str())
            .def(py::init<const typename Class::Data *>(), "data"_a)
            .def("at", &Class::at, py::return_value_policy::reference)
            .def_property_readonly("size", &Class::size)
            .def("__getitem__", &Class::at, py::return_value_policy::reference)
            .def("__len__", &Class::size)
            .def("__repr__",
                 [str_type](const Class &self) {
                     std::string repr = self.repr(true, self.PY_NAMESPACE_SEPARATOR);
                     repr = replace_image_types<T>(repr, str_type, self.PY_NAMESPACE_SEPARATOR);
                     return repr;
                 })
            .def("__str__", [str_type](const Class &self) {
                std::string str = self.str();
                str = replace_image_types<T>(str, str_type, self.CC_NAMESPACE_SEPARATOR);
                return str;
            });
}

declare_maker()

template<typename T , class Data , class Indices >

void lsst::gauss2d::python::declare_maker	(	py::module &	m,
		std::string	str_type )

Definition at line 274 of file image.h.

                                                    {
    m.def(("make_gaussians_pixel_" + str_type).c_str(), lsst::gauss2d::make_gaussians_pixel<T, Data, Indices>,
          "Evaluate a 2D Gaussian at the centers of pixels on a rectangular grid using the standard bivariate"
          "Gaussian PDF.",
          "gaussians"_a, "output"_a = nullptr, "n_rows"_a = 0, "n_cols"_a = 0, "coordsys"_a = nullptr,
          "to_add"_a = false);
}

replace_image_types()

template<typename T >

std::string lsst::gauss2d::python::replace_image_types	(	std::string	target,
		std::string	str_type,
		std::string_view	separator )

Replace a template Image type name with Pythonic names.

Template Parameters

T	The data type of the Image class string to replace.

Parameters

target	The string to replace type names in.
str_type	The replacement string for T.
separator	The namespace separator to replace.

Returns

A replacement string without templated types.

Definition at line 203 of file image.h.

                                                                                              {
    std::string token1 = std::string("<") + type_name_str<T>() + ", ";
    target = replace_all_none(target, token1);
    std::string token2 = type_name_str<Image<T>>(false, separator) + std::string(" >");
    target = replace_all(target, token2, str_type);
    // str appears to return e.g. Image<double> for some reason
    target = replace_type<T>(target, str_type);
    return target;
}

replace_images_types()

template<typename Value , typename Index >

std::string lsst::gauss2d::python::replace_images_types	(	std::string	target,
		std::string	str_type,
		std::string_view	separator )

Replace templated Image and index Image type name with Pythonic names.

Template Parameters

Value	The data type of the Image (data) class string to replace.
Index	The data type of the Image (index) class string to replace.

Parameters

target	The string to replace type names in.
str_type	The replacement string for T.
separator	The namespace separator to replace.

Returns

A replacement string without templated types.

Definition at line 144 of file image.h.

                                                                                               {
    std::string token1 = std::string("<") + type_name_str<Value>() + ", ";
    target = replace_all_none(target, token1);
    std::string token2 = type_name_str<Image<Value>>(false, separator) + std::string(", ");
    target = replace_all_none(target, token2);
    std::string token3 = type_name_str<Image<Index>>(false, separator) + std::string(" >");
    target = replace_all(target, token3, str_type);
    // str appears to return e.g. Image<double> for some reason
    target = replace_type<Value>(target, str_type);
    return target;
}

replace_type()

template<typename T >

std::string lsst::gauss2d::python::replace_type	(	std::string	target,
		std::string	replacement )

Definition at line 50 of file image.h.

                                                                {
    std::string token = "<" + gauss2d::type_name_str<T>() + ">";
    return replace_all(target, token, replacement);
}