lsst::gauss2d Namespace Reference

Namespaces
namespace	detail
namespace	fit
namespace	python
namespace	utils

Classes
class	Centroid
	A 2D coordinate representing the center of a plane figure. More...
class	CentroidData
	Interface for an object storing Centroid data. More...
class	CentroidValues
	A CentroidData storing centroid values as shared_ptrs. More...
class	ConvolvedGaussian
	A convolution of a Gaussian source and kernel. More...
class	ConvolvedGaussians
	A collection of ConvolvedGaussian objects. More...
class	CoordinateSystem
	A coordinate system specifying image scale and orientation. More...
class	Covariance
	A representation of a 2D Gaussian with x and y standard deviations and a covariance value. More...
class	Ellipse
	An Ellipse with sigma_x, sigma_y, and rho values. More...
class	EllipseData
	Interface for an object storing Ellipse data. More...
class	EllipseMajor
	An Ellipse with r_major, axrat and angle values. More...
class	EllipseValues
	An EllipseData storing sigma_x, sigma_y, rho values as shared_ptrs. More...
class	Gaussian
	A 2D Gaussian with a Centroid, Ellipse, and integral. More...
class	GaussianEvaluator
	A class that evaluates 2D Gaussians and renders them in images. More...
class	GaussianIntegral
	Interface for the normalization (total integrated value) of a 2D Gaussian. More...
class	GaussianIntegralValue
	A GaussianIntegral storing a float value. More...
class	Gaussians
	An array of Gaussian objects. More...
class	Image
	A 2D image with scalar numeric values, using CRTP. More...
class	ImageArray
	An array of compatible Images. More...
class	Object
	A generic object from the gauss2d library. More...
class	VectorImage

Typedefs
typedef size_t	idx_type

Enumerations
enum class	BackgroundType : unsigned char { none = 0 , constant = 1 }
enum class	OutputType : unsigned char { none = 0 , overwrite = 1 , add = 2 }
enum class	GradientType : unsigned char { none = 0 , loglike = 1 , jacobian = 2 }

Functions
template<typename T, class Data, class Indices>
std::shared_ptr< Data >	make_gaussians_pixel (const std::shared_ptr< const ConvolvedGaussians > gaussians, std::shared_ptr< Data > output=nullptr, const unsigned int n_rows=0, const unsigned int n_cols=0, const std::shared_ptr< const CoordinateSystem > coordsys=nullptr, bool to_add=false)
	Add gaussians to an image, creating one if needed.
template<typename T1, class C1, typename T2, class C2>
bool	images_compatible (const Image< T1, C1 > &img1, const Image< T2, C2 > &img2, bool compare_coordsys=true, std::string *msg=nullptr)
	Return if two images are compatible.
template<typename T>
std::string	repr_ptr (T ptr, bool name_keywords, std::string_view namespace_separator)
template<typename T>
std::string	repr_iter_ptr (const T &container, bool name_keywords=false, std::string_view namespace_separator=Object::CC_NAMESPACE_SEPARATOR)
template<bool is_wrapper, typename T>
std::string	repr_iter_ref (const T &container, bool name_keywords=false, std::string_view namespace_separator=Object::CC_NAMESPACE_SEPARATOR)
template<bool is_wrapper, typename T>
std::string	repr_map_ref (const T &container, bool name_keywords=false, std::string_view namespace_separator=Object::CC_NAMESPACE_SEPARATOR)
template<typename T>
std::string	str_ptr (T ptr)
template<typename T>
std::string	str_iter_ptr (const T &container)
template<bool is_wrapper, typename T>
std::string	str_iter_ref (const T &container)
template<bool is_wrapper, typename T>
std::string	str_map_ref (const T &container)
template<typename T>
void	stream_iter_ref (const T &container, std::ostream &stream)
template<typename T, typename R>
std::string	replace_all (std::string target, T token, R replacement)
	Replace a token inside a target string with another string.
template<typename T>
std::string	replace_all_none (std::string target, T token)
	Replace a token inside a target string with nothing.
template std::string	replace_all< const std::string, const std::string > (std::string target, const std::string token, const std::string replacement)
template std::string	replace_all< std::string_view, const std::string > (std::string target, std::string_view token, const std::string replacement)
template std::string	replace_all< const std::string, std::string_view > (std::string target, const std::string token, std::string_view replacement)
template std::string	replace_all< std::string_view, std::string_view > (std::string target, std::string_view token, std::string_view replacement)
template std::string	replace_all_none< const std::string > (std::string target, const std::string token)
template std::string	replace_all_none< std::string_view > (std::string target, std::string_view token)
template<typename T>
std::string	to_string_float (const T value, const int precision=6, const bool scientific=true)
template<template< typename... > class Container, class Value>
std::string	to_string_float_iter (const Container< Value > &container, const int precision=6, const bool scientific=true)
template<template< typename... > class Container, class Value>
std::string	to_string_iter (const Container< Value > &container)
template<typename T>
constexpr std::string_view	type_name ()
	Get a string representation of an arbitrary C++ type.
template<>
constexpr std::string_view	type_name< void > ()
template<typename T>
std::string	type_name_str (bool strip_namespace=false, std::string_view namespace_str=detail::NAMESPACE_SEPARATOR)
	Get a string representation of an arbitrary C++ type, potentially modifying its namespace prefix.
template<class S>
std::pair< S, S >	sincos (S arg)
std::ostream &	operator<< (std::ostream &out, const Covariance &obj)
std::pair< double, double >	get_x_pm (double sigma_x_sq, double sigma_y_sq, double cov_xy)
void	init (EllipseMajor &ellipse, const Covariance &covar, bool degrees)
std::ostream &	operator<< (std::ostream &out, const Gaussian &g)

Variables
const double	M_HWHM_SIGMA = 1.1774100225154746910115693264599
const double	M_SIGMA_HWHM = 0.84932180028801904272150283410295
const double	M_PI_180 = M_PI / 180.
const double	M_180_PI = 180. / M_PI
const size_t	N_EXTRA_MAP = 2
const size_t	N_EXTRA_FACTOR = 3
const size_t	N_PARAMS_GAUSS2D = 6

Typedef Documentation

idx_type

typedef size_t lsst::gauss2d::idx_type

Definition at line 43 of file image.h.

Enumeration Type Documentation

BackgroundType

enum class lsst::gauss2d::BackgroundType : unsigned char

strong

Enumerator
none
constant

Definition at line 44 of file evaluate.h.

                          : unsigned char {
    none = 0,
    constant = 1,
};

GradientType

enum class lsst::gauss2d::GradientType : unsigned char

strong

Enumerator
none
loglike
jacobian

Definition at line 53 of file evaluate.h.

                        : unsigned char {
    none = 0,
    loglike = 1,
    jacobian = 2,
};

OutputType

enum class lsst::gauss2d::OutputType : unsigned char

strong

Enumerator
none
overwrite
add

Definition at line 48 of file evaluate.h.

                      : unsigned char {
    none = 0,
    overwrite = 1,
    add = 2,
};

Function Documentation

get_x_pm()

std::pair< double, double > lsst::gauss2d::get_x_pm	(	double	sigma_x_sq,
		double	sigma_y_sq,
		double	cov_xy )

Definition at line 327 of file ellipse.cc.

                                                                                      {
    double apc = sigma_x_sq + sigma_y_sq;
    double x = apc / 2;
    // TODO: Write tests for this with inputs returning close to zero
    // Probably most efficient but unstable, e.g.:
    // sigma_x, sigma_y, rho = 1.58113883008419, 1.5811388300841895, 0
    // ... yields -3.552713678800501e-15 inside the sqrt
    // double pm = sqrt(apc*apc - 4*(sigma_x_sq*sigma_y_sq - cov_xy*cov_xy))/2;
    // Two more multiplications, but seemingly more stable
    // Cancels out cross term from apc (2*sigma_x_sq*sigma_y_sq)
    double pm = (sigma_x_sq * sigma_x_sq + sigma_y_sq * sigma_y_sq
                 - 2 * (sigma_x_sq * sigma_y_sq - 2 * cov_xy * cov_xy));
    // Return zero if the result is negative
    // TODO: Consider checking if < -machine_eps?
    pm = (pm > 0) ? sqrt(pm) / 2 : 0;
    return {x, pm};
}

images_compatible()

template<typename T1, class C1, typename T2, class C2>

bool lsst::gauss2d::images_compatible	(	const Image< T1, C1 > &	img1,
		const Image< T2, C2 > &	img2,
		bool	compare_coordsys = true,
		std::string *	msg = nullptr )

Return if two images are compatible.

Compatible means that they have the same dimensions in both axes and equivalent coordinate systems.

Template Parameters

T1	The data type of C1.
C1	The class of the first Image.
T2	The data type of C2.
C2	The class of the second Image.

Parameters

img1	The first image.
img2	The second image.
msg	A string to append error messages to, if not null.

Returns

true If images are compatible.

Definition at line 70 of file image.h.

                                                 {
    bool coordsys_equal = !compare_coordsys || (img1.get_coordsys() == img2.get_coordsys());
    bool return_msg = msg != nullptr;
    if (!return_msg && !coordsys_equal) return false;
    bool cols_equal = img1.get_n_cols() == img2.get_n_cols();
    bool rows_equal = img1.get_n_rows() == img2.get_n_rows();
    bool passed = coordsys_equal && cols_equal && rows_equal;
    if (!passed) {
        if (return_msg) {
            if (!coordsys_equal) {
                *msg += img1.get_coordsys().str() + "!=" + img2.get_coordsys().str() + ",";
            }
            if (!cols_equal) {
                *msg += std::to_string(img1.get_n_cols()) + "!=" + std::to_string(img2.get_n_cols()) + ",";
            }
            if (!rows_equal) {
                *msg += std::to_string(img1.get_n_rows()) + "!=" + std::to_string(img2.get_n_rows());
            }
        }
        return false;
    }
    return true;
}

init()

void lsst::gauss2d::init	(	EllipseMajor &	ellipse,
		const Covariance &	covar,
		bool	degrees )

Definition at line 345 of file ellipse.cc.

                                                                        {
    double sigma_x_sq = covar.get_sigma_x_sq();
    double sigma_y_sq = covar.get_sigma_y_sq();
    if (sigma_x_sq == 0 && sigma_y_sq == 0) return;
    double cov_xy = covar.get_cov_xy();
    auto [x, pm] = get_x_pm(sigma_x_sq, sigma_y_sq, cov_xy);
    double r_major = x + pm;
    if (r_major == 0) return;
 
    double axrat = sqrt((x - pm) / r_major);
    r_major = sqrt(r_major);
    double ang = atan2(2 * cov_xy, sigma_x_sq - sigma_y_sq) / 2;
    if (degrees) ang *= M_180_PI;
    ellipse.set(r_major, axrat, ang);
}

make_gaussians_pixel()

template<typename T, class Data, class Indices>

std::shared_ptr< Data > lsst::gauss2d::make_gaussians_pixel	(	const std::shared_ptr< const ConvolvedGaussians >	gaussians,
		std::shared_ptr< Data >	output = nullptr,
		const unsigned int	n_rows = 0,
		const unsigned int	n_cols = 0,
		const std::shared_ptr< const CoordinateSystem >	coordsys = nullptr,
		bool	to_add = false )

Add gaussians to an image, creating one if needed.

Template Parameters

t	The data type (e.g. float, int)
Data	The data array class
Indices	The index array class (usually a size_t array)

Parameters

gaussians	The gaussians to add
output	The image to add gaussians to. If null, it will be initialized
n_rows	The number of rows, if creating a new image
n_cols	The number of columns, if creating a new image
coordsys	The image's coordinate system
to_add	Whether to add to an existing image. throws if output is nullptr.

Returns

std::shared_ptr<Data> The output pointer, assigned if originally null

Definition at line 1233 of file evaluate.h.

                                                                {
    if (output == nullptr) {
        if (to_add) {
            throw std::invalid_argument("Cannot set to_add if output is nullptr");
        }
        output = std::make_shared<Data>(n_rows, n_cols, nullptr, coordsys);
    }
    auto evaluator
            = std::make_unique<GaussianEvaluator<T, Data, Indices>>(gaussians, nullptr, nullptr, output);
    evaluator->loglike_pixel(to_add);
    return output;
}

operator<<() [1/2]

std::ostream & lsst::gauss2d::operator<<	(	std::ostream &	out,
		const Covariance &	obj )

Definition at line 137 of file ellipse.cc.

                                                               {
    out << obj.str();
    return out;
}

operator<<() [2/2]

std::ostream & lsst::gauss2d::operator<<	(	std::ostream &	out,
		const Gaussian &	g )

Definition at line 103 of file gaussian.cc.

                                                           {
    out << g.str();
    return out;
}

replace_all()

template<typename T, typename R>

std::string lsst::gauss2d::replace_all	(	std::string	target,
		T	token,
		R	replacement )

Replace a token inside a target string with another string.

Parameters

target	The string to replace and return.
token	The token to replace.
replacement	The token to replace with.

Returns

The target with replacements, if any.

Definition at line 23 of file string_utils.h.

                                                                {
    auto pos = target.find(token, 0);
    const auto n_token = token.size();
    const auto n_replace = replacement.size();
    while (pos != std::string::npos) {
        target.replace(pos, n_token, replacement);
        pos += n_replace;
        pos = target.find(token, pos);
    }
    return target;
}

replace_all< const std::string, const std::string >()

template std::string lsst::gauss2d::replace_all< const std::string, const std::string >	(	std::string	target,
		const std::string	token,
		const std::string	replacement )

replace_all< const std::string, std::string_view >()

template std::string lsst::gauss2d::replace_all< const std::string, std::string_view >	(	std::string	target,
		const std::string	token,
		std::string_view	replacement )

replace_all< std::string_view, const std::string >()

template std::string lsst::gauss2d::replace_all< std::string_view, const std::string >	(	std::string	target,
		std::string_view	token,
		const std::string	replacement )

replace_all< std::string_view, std::string_view >()

template std::string lsst::gauss2d::replace_all< std::string_view, std::string_view >	(	std::string	target,
		std::string_view	token,
		std::string_view	replacement )

replace_all_none()

template<typename T>

std::string lsst::gauss2d::replace_all_none	(	std::string	target,
		T	token )

Replace a token inside a target string with nothing.

Parameters

target	The string to replace and return.
token	The token to replace with an empty string.

Returns

The target with replacements, if any.

Definition at line 43 of file string_utils.h.

                                                      {
    auto pos = target.find(token, 0);
    const auto n_token = token.size();
    while (pos != std::string::npos) {
        target.replace(pos, n_token, "");
        pos = target.find(token, pos);
    }
    return target;
}

replace_all_none< const std::string >()

template std::string lsst::gauss2d::replace_all_none< const std::string >	(	std::string	target,
		const std::string	token )

replace_all_none< std::string_view >()

template std::string lsst::gauss2d::replace_all_none< std::string_view >	(	std::string	target,
		std::string_view	token )

repr_iter_ptr()

template<typename T>

std::string lsst::gauss2d::repr_iter_ptr	(	const T &	container,
		bool	name_keywords = false,
		std::string_view	namespace_separator = Object::CC_NAMESPACE_SEPARATOR )

Definition at line 88 of file object.h.

                                                                                             {
    std::string str = "[";
    for (auto &obj : container) {
        str += repr_ptr(obj, name_keywords, namespace_separator) + ", ";
    }
    auto size_str = str.size();
    if (size_str > 1) str = str.substr(0, size_str - 2);
    return str + "]";
}

repr_iter_ref()

template<bool is_wrapper, typename T>

std::string lsst::gauss2d::repr_iter_ref	(	const T &	container,
		bool	name_keywords = false,
		std::string_view	namespace_separator = Object::CC_NAMESPACE_SEPARATOR )

Definition at line 101 of file object.h.

                                                                                             {
    std::string str = "[";
    for (const auto &obj : container) {
        if constexpr (is_wrapper) {
            str += obj.get().repr(name_keywords, namespace_separator);
        } else {
            str += obj.repr(name_keywords, namespace_separator);
        }
        str += ", ";
    }
    auto size_str = str.size();
    if (size_str > 1) str = str.substr(0, size_str - 2);
    return str + "]";
}

repr_map_ref()

template<bool is_wrapper, typename T>

std::string lsst::gauss2d::repr_map_ref	(	const T &	container,
		bool	name_keywords = false,
		std::string_view	namespace_separator = Object::CC_NAMESPACE_SEPARATOR )

Definition at line 118 of file object.h.

                                                                                            {
    std::string str = "{";
    for (const auto &[obj, value] : container) {
        if constexpr (is_wrapper) {
            str += obj.get().repr(name_keywords, namespace_separator) + ": " + std::to_string(value) + ", ";
        } else {
            str += obj.repr(name_keywords, namespace_separator) + ": " + std::to_string(value) + ", ";
        }
    }
    return str.substr(0, str.size() - 2 * (container.size() > 0)) + "}";
}

repr_ptr()

template<typename T>

std::string lsst::gauss2d::repr_ptr	(	T	ptr,
		bool	name_keywords,
		std::string_view	namespace_separator )

Definition at line 82 of file object.h.

                                                                                  {
    return ptr ? ptr->repr(name_keywords, namespace_separator)
               : std::string(Object::null_str(namespace_separator));
}

sincos()

template<class S>

std::pair< S, S > lsst::gauss2d::sincos

(

S

arg

)

Definition at line 36 of file ellipse.cc.

                            {
    return {std::sin(arg), std::cos(arg)};
}

str_iter_ptr()

template<typename T>

std::string lsst::gauss2d::str_iter_ptr

(

const T &

container

)

Definition at line 137 of file object.h.

                                           {
    std::string str = "[";
    for (const auto &obj : container) {
        str += str_ptr(obj) + ", ";
    }
    auto size_str = str.size();
    if (size_str > 1) str = str.substr(0, size_str - 2);
    return str + "]";
}

str_iter_ref()

template<bool is_wrapper, typename T>

std::string lsst::gauss2d::str_iter_ref

(

const T &

container

)

Definition at line 148 of file object.h.

                                           {
    std::string str = "[";
    for (const auto &obj : container) {
        if constexpr (is_wrapper) {
            str += obj.get().str();
        } else {
            str += obj.str();
        }
        str += ", ";
    }
    auto size_str = str.size();
    if (size_str > 1) str = str.substr(0, size_str - 2);
    return str + "]";
}

str_map_ref()

template<bool is_wrapper, typename T>

std::string lsst::gauss2d::str_map_ref

(

const T &

container

)

Definition at line 164 of file object.h.

                                          {
    std::string str = "{";
    for (const auto &[obj, value] : container) {
        if constexpr (is_wrapper) {
            str += obj.get().str() + ": " + std::to_string(value) + ", ";
        } else {
            str += obj.str() + ": " + std::to_string(value) + ", ";
        }
    }
    return str.substr(0, str.size() - 2 * (container.size() > 0)) + "}";
}

str_ptr()

template<typename T>

std::string lsst::gauss2d::str_ptr

(

T

ptr

)

Definition at line 132 of file object.h.

                         {
    return ptr ? ptr->str() : std::string(Object::NULL_STR_GENERAL);
}

stream_iter_ref()

template<typename T>

void lsst::gauss2d::stream_iter_ref	(	const T &	container,
		std::ostream &	stream )

Definition at line 177 of file object.h.

                                                             {
    stream << "[";
    for (const auto &obj : container) stream << obj << ",";
    stream << "]";
}

to_string_float()

template<typename T>

std::string lsst::gauss2d::to_string_float	(	const T	value,
		const int	precision = 6,
		const bool	scientific = true )

Definition at line 15 of file to_string.h.

                                                                                                {
    std::ostringstream out;
    out.precision(precision);
    if (scientific) {
        out << std::scientific;
    } else {
        out << std::fixed;
    }
    out << value;
    return std::move(out).str();
}

to_string_float_iter()

template<template< typename... > class Container, class Value>

std::string lsst::gauss2d::to_string_float_iter	(	const Container< Value > &	container,
		const int	precision = 6,
		const bool	scientific = true )

Definition at line 28 of file to_string.h.

                                                               {
    std::string str = "[";
    for (const auto& value : container) {
        str += to_string_float(value, precision, scientific) + ", ";
    }
    return str.substr(0, str.size() - 2 * (container.size() > 0)) + "]";
}

to_string_iter()

template<template< typename... > class Container, class Value>

std::string lsst::gauss2d::to_string_iter

(

const Container< Value > &

container

)

Definition at line 38 of file to_string.h.

                                                            {
    std::string str = "[";
    for (const auto& value : container) {
        str += std::to_string(value) + ", ";
    }
    return str.substr(0, str.size() - 2 * (container.size() > 0)) + "]";
}

type_name()

template<typename T>

std::string_view lsst::gauss2d::type_name ( )

constexpr

Get a string representation of an arbitrary C++ type.

Template Parameters

T	The type to stringify

Returns

A string representation of the type's name

Note

Adapted from https://stackoverflow.com/a/64490578

Definition at line 84 of file type_name.h.

                                     {
    constexpr auto wrapped_name = detail::wrapped_type_name<T>();
    constexpr auto prefix_length = detail::wrapped_type_name_prefix_length();
    constexpr auto suffix_length = detail::wrapped_type_name_suffix_length();
    constexpr auto type_name_length = wrapped_name.length() - prefix_length - suffix_length;
    return wrapped_name.substr(prefix_length, type_name_length);
}

type_name< void >()

template<>

std::string_view lsst::gauss2d::type_name< void > ( )

constexpr

Definition at line 39 of file type_name.h.

                                           {
    return "void";
}

type_name_str()

template<typename T>

std::string lsst::gauss2d::type_name_str	(	bool	strip_namespace = false,
		std::string_view	namespace_str = detail::NAMESPACE_SEPARATOR )

Get a string representation of an arbitrary C++ type, potentially modifying its namespace prefix.

Template Parameters

T	The type to stringify.

Parameters

strip_namespace	Whether to strip the namespace prefix entirely.
namespace_str	A string to replace the standard C++ namespace separator (i.e. ::) with; generally . for Python.

Returns

A string representation of the type's name, with modified namespace prefix.

Definition at line 104 of file type_name.h.

                                                                                    {
    std::string name = std::string(type_name<T>());
    if (strip_namespace) {
        // Find the first template specifier (if any), then find the last colon
        auto prefix = name.substr(0, name.find_first_of('<'));
        return name.substr(prefix.find_last_of(':') + 1, std::string::npos);
    } else if (namespace_str != detail::NAMESPACE_SEPARATOR) {
        name = replace_all(name, detail::NAMESPACE_SEPARATOR, namespace_str);
    }
    return name;
}

Variable Documentation

M_180_PI

const double lsst::gauss2d::M_180_PI = 180. / M_PI

Definition at line 41 of file ellipse.h.

M_HWHM_SIGMA

const double lsst::gauss2d::M_HWHM_SIGMA = 1.1774100225154746910115693264599

Definition at line 38 of file ellipse.h.

M_PI_180

const double lsst::gauss2d::M_PI_180 = M_PI / 180.

Definition at line 40 of file ellipse.h.

M_SIGMA_HWHM

const double lsst::gauss2d::M_SIGMA_HWHM = 0.84932180028801904272150283410295

Definition at line 39 of file ellipse.h.

N_EXTRA_FACTOR

const size_t lsst::gauss2d::N_EXTRA_FACTOR = 3

Definition at line 60 of file evaluate.h.

N_EXTRA_MAP

const size_t lsst::gauss2d::N_EXTRA_MAP = 2

Definition at line 59 of file evaluate.h.

N_PARAMS_GAUSS2D

const size_t lsst::gauss2d::N_PARAMS_GAUSS2D = 6

Definition at line 61 of file evaluate.h.