lsst::sphgeom Namespace Reference

Namespaces
namespace	_continue_class
namespace	_healpixPixelization
namespace	_yaml
namespace	detail
namespace	pixelization_abc
namespace	python
namespace	version

Classes
class	Angle
	Angle represents an angle in radians. More...
class	AngleInterval
	AngleInterval represents closed intervals of arbitrary angles. More...
class	BigInteger
	BigInteger is an arbitrary precision signed integer class. More...
class	Box
	Box represents a rectangle in spherical coordinate space that contains its boundary. More...
class	Box3d
	Box3d represents a box in ℝ³. More...
class	Chunker
	Chunker subdivides the unit sphere into longitude-latitude boxes. More...
class	Circle
	Circle is a circular region on the unit sphere that contains its boundary. More...
class	CompoundRegion
	CompoundRegion is an intermediate base class for spherical regions that are comprised of a point-set operation on other nested regions. More...
class	ConvexPolygon
	ConvexPolygon is a closed convex polygon on the unit sphere. More...
class	Ellipse
	Ellipse is an elliptical region on the sphere. More...
class	HtmPixelization
	HtmPixelization provides HTM indexing of points and regions. More...
class	IntersectionRegion
	IntersectionRegion is a lazy point-set inersection of its operands. More...
class	Interval
	Interval represents a closed interval of the real numbers by its upper and lower bounds. More...
class	Interval1d
	Interval1d represents closed intervals of ℝ. More...
class	LonLat
	LonLat represents a spherical coordinate (longitude/latitude angle) pair. More...
class	Matrix3d
	A 3x3 matrix with real entries stored in double precision. More...
class	Mq3cPixelization
	Mq3cPixelization provides modified Q3C indexing of points and regions. More...
class	NormalizedAngle
	NormalizedAngle is an angle that lies in the range [0, 2π), with one exception - a NormalizedAngle can be NaN. More...
class	NormalizedAngleInterval
	NormalizedAngleInterval represents closed intervals of normalized angles, i.e. More...
class	Pixelization
	A Pixelization (or partitioning) of the sphere is a mapping between points on the sphere and a set of pixels (a.k.a. More...
class	Q3cPixelization
	Q3cPixelization provides Q3C indexing of points and regions. More...
class	RangeSet
	A RangeSet is a set of unsigned 64 bit integers. More...
class	Region
	Region is a minimal interface for 2-dimensional regions on the unit sphere. More...
struct	SubChunks
	SubChunks represents a set of sub-chunks of a particular chunk. More...
class	TriState
	TriState represents a boolean value with additional unknown state. More...
class	UnionRegion
	UnionRegion is a lazy point-set union of its operands. More...
class	UnitVector3d
	UnitVector3d is a unit vector in ℝ³ with components stored in double precision. More...
class	Vector3d
	Vector3d is a vector in ℝ³ with components stored in double precision. More...

Typedefs
using	Relationship = std::bitset<3>
	Relationship describes how two sets are related.

Functions
Angle	operator* (double a, Angle const &b)
std::ostream &	operator<< (std::ostream &, Angle const &)
double	sin (Angle const &a)
double	cos (Angle const &a)
double	tan (Angle const &a)
Angle	abs (Angle const &a)
std::ostream &	operator<< (std::ostream &, AngleInterval const &)
std::ostream &	operator<< (std::ostream &, Box const &)
std::ostream &	operator<< (std::ostream &, Box3d const &)
std::ostream &	operator<< (std::ostream &, Circle const &)
void	encodeDouble (double item, std::vector< std::uint8_t > &buffer)
	encodeDouble appends an IEEE double in little-endian byte order to the end of buffer.
double	decodeDouble (std::uint8_t const *buffer)
	decodeDouble extracts an IEEE double from the 8 byte little-endian byte sequence in buffer.
void	encodeU64 (std::uint64_t item, std::vector< std::uint8_t > &buffer)
	encodeU64 appends an uint64 in little-endian byte order to the end of buffer.
std::uint64_t	decodeU64 (std::uint8_t const *buffer)
	decodeU64 extracts an uint64 from the 8 byte little-endian byte sequence in buffer.
std::ostream &	operator<< (std::ostream &, ConvexPolygon const &)
std::uint64_t	mortonIndex (std::uint32_t x, std::uint32_t y)
	mortonIndex interleaves the bits of x and y.
std::tuple< std::uint32_t, std::uint32_t >	mortonIndexInverse (std::uint64_t z)
	mortonIndexInverse separates the even and odd bits of z.
std::uint64_t	mortonToHilbert (std::uint64_t z, int m)
	mortonToHilbert converts the 2m-bit Morton index z to the corresponding Hilbert index.
std::uint64_t	hilbertToMorton (std::uint64_t h, int m)
	hilbertToMorton converts the 2m-bit Hilbert index h to the corresponding Morton index.
std::uint64_t	hilbertIndex (std::uint32_t x, std::uint32_t y, int m)
	hilbertIndex returns the index of (x, y) in a 2-D Hilbert curve.
std::tuple< std::uint32_t, std::uint32_t >	hilbertIndexInverse (std::uint64_t h, int m)
	hilbertIndexInverse returns the point (x, y) with Hilbert index h, where x and y are m bit integers.
std::ostream &	operator<< (std::ostream &, Ellipse const &)
std::ostream &	operator<< (std::ostream &, Interval1d const &)
std::ostream &	operator<< (std::ostream &, LonLat const &)
std::ostream &	operator<< (std::ostream &, Matrix3d const &)
NormalizedAngle const &	abs (NormalizedAngle const &a)
std::ostream &	operator<< (std::ostream &, NormalizedAngleInterval const &)
int	orientationExact (Vector3d const &a, Vector3d const &b, Vector3d const &c)
	orientationExact computes and returns the orientations of 3 vectors a, b and c, which need not be normalized but are assumed to have finite components.
int	orientation (UnitVector3d const &a, UnitVector3d const &b, UnitVector3d const &c)
	orientation computes and returns the orientations of 3 unit vectors a, b and c.
int	orientationX (UnitVector3d const &b, UnitVector3d const &c)
	orientationX(b, c) is equivalent to orientation(UnitVector3d::X(), b, c).
int	orientationY (UnitVector3d const &b, UnitVector3d const &c)
	orientationY(b, c) is equivalent to orientation(UnitVector3d::Y(), b, c).
int	orientationZ (UnitVector3d const &b, UnitVector3d const &c)
	orientationZ(b, c) is equivalent to orientation(UnitVector3d::Z(), b, c).
template<typename Pybind11Class>
void	defineClass (Pybind11Class &cls)
void	swap (RangeSet &a, RangeSet &b)
std::ostream &	operator<< (std::ostream &, RangeSet const &)
Relationship	invert (Relationship r)
	Given the relationship between two sets A and B (i.e.
std::ostream &	operator<< (std::ostream &stream, TriState const &value)
std::ostream &	operator<< (std::ostream &, UnitVector3d const &)
double	getMinSquaredChordLength (Vector3d const &v, Vector3d const &a, Vector3d const &b, Vector3d const &n)
	Let p be the unit vector closest to v that lies on the plane with normal n in the direction of the cross product of a and b.
double	getMaxSquaredChordLength (Vector3d const &v, Vector3d const &a, Vector3d const &b, Vector3d const &n)
	Let p be the unit vector furthest from v that lies on the plane with normal n in the direction of the cross product of a and b.
Angle	getMinAngleToCircle (Angle x, Angle c)
	getMinAngleToCircle returns the minimum angular separation between a point at latitude x and the points on the circle of constant latitude c.
Angle	getMaxAngleToCircle (Angle x, Angle c)
	getMaxAngleToCircle returns the maximum angular separation between a point at latitude x and the points on the circle of constant latitude c.
Vector3d	getWeightedCentroid (UnitVector3d const &v0, UnitVector3d const &v1, UnitVector3d const &v2)
	getWeightedCentroid returns the center of mass of the given spherical triangle (assuming a uniform mass distribution over the triangle surface), weighted by the triangle area.
Vector3d	operator* (double s, Vector3d const &v)
std::ostream &	operator<< (std::ostream &, Vector3d const &)
template<>
void	defineClass (py::class_< Angle > &cls)
template<>
void	defineClass (py::class_< AngleInterval, std::shared_ptr< AngleInterval > > &cls)
template<>
void	defineClass (py::class_< Box, std::unique_ptr< Box >, Region > &cls)
template<>
void	defineClass (py::class_< Box3d, std::shared_ptr< Box3d > > &cls)
template<>
void	defineClass (py::class_< Chunker, std::shared_ptr< Chunker > > &cls)
template<>
void	defineClass (py::class_< Circle, std::unique_ptr< Circle >, Region > &cls)
template<>
void	defineClass (py::class_< CompoundRegion, std::unique_ptr< CompoundRegion >, Region > &cls)
template<>
void	defineClass (py::class_< UnionRegion, std::unique_ptr< UnionRegion >, CompoundRegion > &cls)
template<>
void	defineClass (py::class_< IntersectionRegion, std::unique_ptr< IntersectionRegion >, CompoundRegion > &cls)
template<>
void	defineClass (py::class_< ConvexPolygon, std::unique_ptr< ConvexPolygon >, Region > &cls)
void	defineCurve (py::module &mod)
template<>
void	defineClass (py::class_< Ellipse, std::unique_ptr< Ellipse >, Region > &cls)
template<>
void	defineClass (py::class_< HtmPixelization, Pixelization > &cls)
template<>
void	defineClass (py::class_< Interval1d, std::shared_ptr< Interval1d > > &cls)
template<>
void	defineClass (py::class_< LonLat, std::shared_ptr< LonLat > > &cls)
template<>
void	defineClass (py::class_< Matrix3d, std::shared_ptr< Matrix3d > > &cls)
template<>
void	defineClass (py::class_< Mq3cPixelization, Pixelization > &cls)
template<>
void	defineClass (py::class_< NormalizedAngle > &cls)
template<>
void	defineClass (py::class_< NormalizedAngleInterval, std::shared_ptr< NormalizedAngleInterval > > &cls)
void	defineOrientation (py::module &mod)
template<>
void	defineClass (py::class_< Pixelization > &cls)
template<>
void	defineClass (py::class_< Q3cPixelization, Pixelization > &cls)
template<>
void	defineClass (py::class_< RangeSet, std::shared_ptr< RangeSet > > &cls)
template<>
void	defineClass (py::class_< Region, std::unique_ptr< Region > > &cls)
void	defineRelationship (py::module &mod)
void	defineUtils (py::module &)
template<>
void	defineClass (py::class_< UnitVector3d, std::shared_ptr< UnitVector3d > > &cls)
template<>
void	defineClass (py::class_< Vector3d, std::shared_ptr< Vector3d > > &cls)
std::uint8_t	log2 (std::uint64_t x)
std::uint8_t	log2 (std::uint32_t x)

Variables
constexpr double	PI = 3.1415926535897932384626433832795
constexpr double	ONE_OVER_PI = 0.318309886183790671537767526745
constexpr double	RAD_PER_DEG = 0.0174532925199432957692369076849
constexpr double	DEG_PER_RAD = 57.2957795130823208767981548141
constexpr double	MAX_ASIN_ERROR = 1.5e-8
constexpr double	MAX_SQUARED_CHORD_LENGTH_ERROR = 2.5e-15
constexpr double	EPSILON = 1.1102230246251565e-16

Detailed Description

lsst.sphgeom

Typedef Documentation

Relationship

using lsst::sphgeom::Relationship = std::bitset<3>

Relationship describes how two sets are related.

Definition at line 42 of file Relationship.h.

Function Documentation

abs() [1/2]

Angle lsst::sphgeom::abs ( Angle const & a )

inline

Definition at line 113 of file Angle.h.

{ return Angle(std::fabs(a.asRadians())); }

abs() [2/2]

NormalizedAngle const & lsst::sphgeom::abs ( NormalizedAngle const & a )

inline

Definition at line 159 of file NormalizedAngle.h.

{ return a; }

cos()

double lsst::sphgeom::cos ( Angle const & a )

inline

Definition at line 110 of file Angle.h.

{ return std::cos(a.asRadians()); }

decodeDouble()

double lsst::sphgeom::decodeDouble ( std::uint8_t const * buffer )

inline

decodeDouble extracts an IEEE double from the 8 byte little-endian byte sequence in buffer.

Definition at line 77 of file codec.h.

                                                      {
#ifdef OPTIMIZED_LITTLE_ENDIAN
    return *reinterpret_cast<double const *>(buffer);
#else
    union { std::uint64_t u; double d; };
    u = static_cast<std::uint64_t>(buffer[0]) +
        (static_cast<std::uint64_t>(buffer[1]) << 8) +
        (static_cast<std::uint64_t>(buffer[2]) << 16) +
        (static_cast<std::uint64_t>(buffer[3]) << 24) +
        (static_cast<std::uint64_t>(buffer[4]) << 32) +
        (static_cast<std::uint64_t>(buffer[5]) << 40) +
        (static_cast<std::uint64_t>(buffer[6]) << 48) +
        (static_cast<std::uint64_t>(buffer[7]) << 56);
    return d;
#endif
}

decodeU64()

std::uint64_t lsst::sphgeom::decodeU64 ( std::uint8_t const * buffer )

inline

decodeU64 extracts an uint64 from the 8 byte little-endian byte sequence in buffer.

Definition at line 116 of file codec.h.

                                                        {
#ifdef OPTIMIZED_LITTLE_ENDIAN
    return *reinterpret_cast<std::uint64_t const *>(buffer);
#else
    std::uint64_t u = static_cast<std::uint64_t>(buffer[0]) +
        (static_cast<std::uint64_t>(buffer[1]) << 8) +
        (static_cast<std::uint64_t>(buffer[2]) << 16) +
        (static_cast<std::uint64_t>(buffer[3]) << 24) +
        (static_cast<std::uint64_t>(buffer[4]) << 32) +
        (static_cast<std::uint64_t>(buffer[5]) << 40) +
        (static_cast<std::uint64_t>(buffer[6]) << 48) +
        (static_cast<std::uint64_t>(buffer[7]) << 56);
    return u;
#endif
}

defineClass() [1/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Angle > &

cls

)

Definition at line 43 of file _angle.cc.

                                       {
    cls.def_static("nan", &Angle::nan);
    cls.def_static("fromDegrees", &Angle::fromDegrees);
    cls.def_static("fromRadians", &Angle::fromRadians);
 
    cls.def(py::init<>());
    cls.def(py::init<double>(), "radians"_a);
    cls.def(py::init<Angle>(), "angle"_a);
    // Construct an Angle from a NormalizedAngle, enabling implicit
    // conversion from NormalizedAngle to Angle in python via
    // py::implicitly_convertible
    cls.def(py::init(
            [](NormalizedAngle &a) {
                return new Angle(a.asRadians());
            }),
            "normalizedAngle"_a);
 
    cls.def("__eq__", &Angle::operator==, py::is_operator());
    cls.def("__ne__", &Angle::operator!=, py::is_operator());
    cls.def("__lt__", &Angle::operator<, py::is_operator());
    cls.def("__gt__", &Angle::operator>, py::is_operator());
    cls.def("__le__", &Angle::operator<=, py::is_operator());
    cls.def("__ge__", &Angle::operator>=, py::is_operator());
 
    cls.def("__neg__", (Angle(Angle::*)() const) & Angle::operator-);
    cls.def("__add__", &Angle::operator+, py::is_operator());
    cls.def("__sub__",
            (Angle(Angle::*)(Angle const &) const) & Angle::operator-,
            py::is_operator());
    cls.def("__mul__", &Angle::operator*, py::is_operator());
    cls.def("__rmul__", &Angle::operator*, py::is_operator());
    cls.def("__truediv__", (Angle(Angle::*)(double) const) & Angle::operator/,
            py::is_operator());
    cls.def("__truediv__",
            (double (Angle::*)(Angle const &) const) & Angle::operator/,
            py::is_operator());
 
    cls.def("__iadd__", &Angle::operator+=);
    cls.def("__isub__", &Angle::operator-=);
    cls.def("__imul__", &Angle::operator*=);
    cls.def("__itruediv__", &Angle::operator/=);
 
    cls.def("asDegrees", &Angle::asDegrees);
    cls.def("asRadians", &Angle::asRadians);
    cls.def("isNormalized", &Angle::isNormalized);
    cls.def("isNan", &Angle::isNan);
 
    cls.def("__str__", [](Angle const &self) {
        return py::str("{!s}").format(self.asRadians());
    });
    cls.def("__repr__", [](Angle const &self) {
        return py::str("Angle({!r})").format(self.asRadians());
    });
 
    cls.def("__reduce__", [cls](Angle const &self) {
        return py::make_tuple(cls, py::make_tuple(self.asRadians()));
    });
}

defineClass() [2/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< AngleInterval, std::shared_ptr< AngleInterval > > &

cls

)

Definition at line 43 of file _angleInterval.cc.

                                                                    {
    python::defineInterval<decltype(cls), AngleInterval, Angle>(cls);
 
    cls.def_static("fromDegrees", &AngleInterval::fromDegrees, "x"_a, "y"_a);
    cls.def_static("fromRadians", &AngleInterval::fromRadians, "x"_a, "y"_a);
    cls.def_static("empty", &AngleInterval::empty);
    cls.def_static("full", &AngleInterval::full);
 
    cls.def(py::init<>());
    cls.def(py::init<Angle>(), "x"_a);
    cls.def(py::init<Angle, Angle>(), "x"_a, "y"_a);
    cls.def(py::init<AngleInterval const &>(), "interval"_a);
 
    cls.def("__str__", [](AngleInterval const &self) {
        return py::str("[{!s}, {!s}]")
                .format(self.getA().asRadians(), self.getB().asRadians());
    });
    cls.def("__repr__", [](AngleInterval const &self) {
        return py::str("AngleInterval.fromRadians({!r}, {!r})")
                .format(self.getA().asRadians(), self.getB().asRadians());
    });
}

defineClass() [3/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Box, std::unique_ptr< Box >, Region > &

cls

)

Definition at line 55 of file _box.cc.

                                                                 {
    cls.attr("TYPE_CODE") = py::int_(Box::TYPE_CODE);
 
    cls.def_static("fromDegrees", &Box::fromDegrees, "lon1"_a, "lat1"_a,
                   "lon2"_a, "lat2"_a);
    cls.def_static("fromRadians", &Box::fromRadians, "lon1"_a, "lat1"_a,
                   "lon2"_a, "lat2"_a);
    cls.def_static("empty", &Box::empty);
    cls.def_static("full", &Box::full);
    cls.def_static("halfWidthForCircle", &Box::halfWidthForCircle, "radius"_a,
                   "lat"_a);
    cls.def_static("allLongitudes", &Box::allLongitudes);
    cls.def_static("allLatitudes", &Box::allLatitudes);
 
    cls.def(py::init<>());
    cls.def(py::init<LonLat const &>(), "point"_a);
    cls.def(py::init<LonLat const &, LonLat const &>(), "point1"_a, "point2"_a);
    cls.def(py::init<LonLat const &, Angle, Angle>(), "center"_a, "width"_a,
            "height"_a);
    cls.def(py::init<NormalizedAngleInterval const &, AngleInterval const &>(),
            "lon"_a, "lat"_a);
    cls.def(py::init<Box const &>(), "box"_a);
 
    cls.def("__eq__", (bool (Box::*)(Box const &) const) & Box::operator==,
            py::is_operator());
    cls.def("__eq__", (bool (Box::*)(LonLat const &) const) & Box::operator==,
            py::is_operator());
    cls.def("__ne__", (bool (Box::*)(Box const &) const) & Box::operator!=,
            py::is_operator());
    cls.def("__ne__", (bool (Box::*)(LonLat const &) const) & Box::operator!=,
            py::is_operator());
    cls.def("__contains__",
            (bool (Box::*)(LonLat const &) const) & Box::contains,
            py::is_operator());
    cls.def("__contains__", (bool (Box::*)(Box const &) const) & Box::contains,
            py::is_operator());
    // Rewrap this base class method since there are overloads in this subclass
    cls.def("__contains__",
            (bool (Box::*)(UnitVector3d const &) const) & Box::contains,
            py::is_operator());
 
    cls.def("getLon", &Box::getLon);
    cls.def("getLat", &Box::getLat);
    cls.def("isFull", &Box::isFull);
    cls.def("getCenter", &Box::getCenter);
    cls.def("getWidth", &Box::getWidth);
    cls.def("getHeight", &Box::getHeight);
    cls.def("contains", (bool (Box::*)(LonLat const &) const) & Box::contains);
    cls.def("contains", (bool (Box::*)(Box const &) const) & Box::contains);
    // Rewrap these base class methods since there are overloads in this subclass
    cls.def("contains",
            (bool (Box::*)(UnitVector3d const &) const) & Box::contains);
    cls.def("contains", py::vectorize((bool (Box::*)(double, double, double) const)&Box::contains),
            "x"_a, "y"_a, "z"_a);
    cls.def("contains", py::vectorize((bool (Box::*)(double, double) const)&Box::contains),
            "lon"_a, "lat"_a);
    cls.def("isDisjointFrom",
            (bool (Box::*)(LonLat const &) const) & Box::isDisjointFrom);
    cls.def("isDisjointFrom",
            (bool (Box::*)(Box const &) const) & Box::isDisjointFrom);
    cls.def("intersects",
            (bool (Box::*)(LonLat const &) const) & Box::intersects);
    cls.def("intersects", (bool (Box::*)(Box const &) const) & Box::intersects);
    cls.def("isWithin", (bool (Box::*)(LonLat const &) const) & Box::isWithin);
    cls.def("isWithin", (bool (Box::*)(Box const &) const) & Box::isWithin);
    cls.def("clipTo", (Box & (Box::*)(LonLat const &)) & Box::clipTo);
    cls.def("clipTo", (Box & (Box::*)(Box const &)) & Box::clipTo);
    cls.def("clippedTo", (Box(Box::*)(LonLat const &) const) & Box::clippedTo);
    cls.def("clippedTo", (Box(Box::*)(Box const &) const) & Box::clippedTo);
    cls.def("expandTo", (Box & (Box::*)(LonLat const &)) & Box::expandTo);
    cls.def("expandTo", (Box & (Box::*)(Box const &)) & Box::expandTo);
    cls.def("expandedTo",
            (Box(Box::*)(LonLat const &) const) & Box::expandedTo);
    cls.def("expandedTo", (Box(Box::*)(Box const &) const) & Box::expandedTo);
    cls.def("dilateBy", (Box & (Box::*)(Angle)) & Box::dilateBy, "angle"_a);
    cls.def("dilateBy", (Box & (Box::*)(Angle, Angle)) & Box::dilateBy,
            "width"_a, "height"_a);
    cls.def("dilatedBy", (Box(Box::*)(Angle) const) & Box::dilatedBy,
            "angle"_a);
    cls.def("dilatedBy", (Box(Box::*)(Angle, Angle) const) & Box::dilatedBy,
            "width"_a, "height"_a);
    cls.def("erodeBy", (Box & (Box::*)(Angle)) & Box::erodeBy, "angle"_a);
    cls.def("erodeBy", (Box & (Box::*)(Angle, Angle)) & Box::erodeBy, "width"_a,
            "height"_a);
    cls.def("erodedBy", (Box(Box::*)(Angle) const) & Box::erodedBy, "angle"_a);
    cls.def("erodedBy", (Box(Box::*)(Angle, Angle) const) & Box::erodedBy,
            "width"_a, "height"_a);
    cls.def("getArea", &Box::getArea);
    cls.def("relate",
            (Relationship(Box::*)(LonLat const &) const) & Box::relate,
            "point"_a);
    // Rewrap this base class method since there are overloads in this subclass
    cls.def("relate",
            (Relationship(Box::*)(Region const &) const) & Box::relate,
            "region"_a);
 
    // Note that the Region interface has already been wrapped.
 
    cls.def("__str__", [](Box const &self) {
        return py::str("Box({!s}, {!s})").format(self.getLon(), self.getLat());
    });
    cls.def("__repr__", [](Box const &self) {
        return py::str("Box({!r}, {!r})").format(self.getLon(), self.getLat());
    });
    cls.def(py::pickle(&python::encode, &python::decode<Box>));
}

defineClass() [4/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Box3d, std::shared_ptr< Box3d > > &

cls

)

Definition at line 45 of file _box3d.cc.

                                                             {
    cls.def_static("empty", &Box3d::empty);
    cls.def_static("full", &Box3d::full);
    cls.def_static("aroundUnitSphere", &Box3d::aroundUnitSphere);
 
    cls.def(py::init<>());
    cls.def(py::init<Vector3d const &>(), "vector"_a);
    cls.def(py::init<Vector3d const &, Vector3d const &>(), "vector1"_a,
            "vector2"_a);
    cls.def(py::init<Vector3d const &, double, double, double>(), "center"_a,
            "halfWidth"_a, "halfHeight"_a, "halfDepth"_a);
    cls.def(py::init<Interval1d const &, Interval1d const &,
                     Interval1d const &>(),
            "x"_a, "y"_a, "z"_a);
    cls.def(py::init<Box3d const &>(), "box3d"_a);
 
    cls.def("__eq__",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::operator==,
            py::is_operator());
    cls.def("__eq__",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::operator==,
            py::is_operator());
    cls.def("__ne__",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::operator!=,
            py::is_operator());
    cls.def("__ne__",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::operator!=,
            py::is_operator());
    cls.def("__contains__",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::contains,
            py::is_operator());
    cls.def("__contains__",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::contains,
            py::is_operator());
    cls.def("__len__", [](Box3d const &self) { return py::int_(3); });
    cls.def("__getitem__", [](Box3d const &self, py::int_ row) {
        return self(static_cast<int>(python::convertIndex(3, row)));
    });
 
    cls.def("x", &Box3d::x);
    cls.def("y", &Box3d::y);
    cls.def("z", &Box3d::z);
    cls.def("isEmpty", &Box3d::isEmpty);
    cls.def("isFull", &Box3d::isFull);
    cls.def("getCenter", &Box3d::getCenter);
    cls.def("getWidth", &Box3d::getWidth);
    cls.def("getHeight", &Box3d::getHeight);
    cls.def("getDepth", &Box3d::getDepth);
 
    cls.def("contains",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::contains);
    cls.def("contains",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::contains);
    cls.def("contains", py::vectorize((bool (Box3d::*)(double, double, double) const)&Box3d::contains),
            "x"_a, "y"_a, "z"_a);
    cls.def("isDisjointFrom",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::isDisjointFrom);
    cls.def("isDisjointFrom",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::isDisjointFrom);
    cls.def("intersects",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::intersects);
    cls.def("intersects",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::intersects);
    cls.def("isWithin",
            (bool (Box3d::*)(Vector3d const &) const) & Box3d::isWithin);
    cls.def("isWithin",
            (bool (Box3d::*)(Box3d const &) const) & Box3d::isWithin);
 
    cls.def("clipTo", (Box3d & (Box3d::*)(Vector3d const &)) & Box3d::clipTo);
    cls.def("clipTo", (Box3d & (Box3d::*)(Box3d const &)) & Box3d::clipTo);
    cls.def("clippedTo",
            (Box3d(Box3d::*)(Vector3d const &) const) & Box3d::clippedTo);
    cls.def("clippedTo",
            (Box3d(Box3d::*)(Box3d const &) const) & Box3d::clippedTo);
    cls.def("expandTo",
            (Box3d & (Box3d::*)(Vector3d const &)) & Box3d::expandTo);
    cls.def("expandTo", (Box3d & (Box3d::*)(Box3d const &)) & Box3d::expandTo);
    cls.def("expandedTo",
            (Box3d(Box3d::*)(Vector3d const &) const) & Box3d::expandedTo);
    cls.def("expandedTo",
            (Box3d(Box3d::*)(Box3d const &) const) & Box3d::expandedTo);
 
    cls.def("dilateBy", (Box3d & (Box3d::*)(double)) & Box3d::dilateBy,
            "radius"_a);
    cls.def("dilateBy",
            (Box3d & (Box3d::*)(double, double, double)) & Box3d::dilateBy,
            "width"_a, "height"_a, "depth"_a);
    cls.def("dilatedBy", (Box3d(Box3d::*)(double) const) & Box3d::dilatedBy,
            "radius"_a);
    cls.def("dilatedBy",
            (Box3d(Box3d::*)(double, double, double) const) & Box3d::dilatedBy,
            "width"_a, "height"_a, "depth"_a);
    cls.def("erodeBy", (Box3d & (Box3d::*)(double)) & Box3d::erodeBy,
            "radius"_a);
    cls.def("erodeBy",
            (Box3d & (Box3d::*)(double, double, double)) & Box3d::erodeBy,
            "width"_a, "height"_a, "depth"_a);
    cls.def("erodedBy", (Box3d(Box3d::*)(double) const) & Box3d::erodedBy,
            "radius"_a);
    cls.def("erodedBy",
            (Box3d(Box3d::*)(double, double, double) const) & Box3d::erodedBy,
            "width"_a, "height"_a, "depth"_a);
 
    cls.def("relate",
            (Relationship(Box3d::*)(Vector3d const &) const) & Box3d::relate);
    cls.def("relate",
            (Relationship(Box3d::*)(Box3d const &) const) & Box3d::relate);
 
    cls.def("__str__", [](Box3d const &self) {
        return py::str("[{!s},\n"
                       " {!s},\n"
                       " {!s}]")
                .format(self.x(), self.y(), self.z());
    });
    cls.def("__repr__", [](Box3d const &self) {
        return py::str("Box3d({!r},\n"
                       "      {!r},\n"
                       "      {!r})")
                .format(self.x(), self.y(), self.z());
    });
    cls.def("__reduce__", [cls](Box3d const &self) {
        return py::make_tuple(cls,
                              py::make_tuple(self.x(), self.y(), self.z()));
    });
}

defineClass() [5/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Chunker, std::shared_ptr< Chunker > > &

cls

)

Definition at line 50 of file _chunker.cc.

                                                                 {
    cls.def(py::init<int32_t, int32_t>(), "numStripes"_a,
            "numSubStripesPerStripe"_a);
 
    cls.def("__eq__", &Chunker::operator==, py::is_operator());
    cls.def("__ne__", &Chunker::operator!=, py::is_operator());
 
    cls.def_property_readonly("numStripes", &Chunker::getNumStripes);
    cls.def_property_readonly("numSubStripesPerStripe",
                              &Chunker::getNumSubStripesPerStripe);
 
    cls.def("getChunksIntersecting", &Chunker::getChunksIntersecting,
            "region"_a);
    cls.def("getSubChunksIntersecting",
            [](Chunker const &self, Region const &region) {
                py::list results;
                for (auto const &sc : self.getSubChunksIntersecting(region)) {
                    results.append(py::make_tuple(sc.chunkId, sc.subChunkIds));
                }
                return results;
            },
            "region"_a);
    cls.def("getAllChunks", &Chunker::getAllChunks);
    cls.def("getAllSubChunks", &Chunker::getAllSubChunks, "chunkId"_a);
 
    cls.def("getChunkBoundingBox", &Chunker::getChunkBoundingBox, "stripe"_a, "chunk"_a);
    cls.def("getSubChunkBoundingBox", &Chunker::getSubChunkBoundingBox, "subStripe"_a, "subChunk"_a);
 
    cls.def("getStripe", &Chunker::getStripe, "chunkId"_a);
    cls.def("getChunk", &Chunker::getChunk, "chunkId"_a, "stripe"_a);
 
 
    cls.def("__str__", &toString);
    cls.def("__repr__", &toString);
 
    cls.def("__reduce__", [cls](Chunker const &self) {
        return py::make_tuple(cls,
                              py::make_tuple(self.getNumStripes(),
                                             self.getNumSubStripesPerStripe()));
    });
}

defineClass() [6/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Circle, std::unique_ptr< Circle >, Region > &

cls

)

Definition at line 51 of file _circle.cc.

                                                                       {
    cls.attr("TYPE_CODE") = py::int_(Circle::TYPE_CODE);
 
    cls.def_static("empty", &Circle::empty);
    cls.def_static("full", &Circle::full);
    cls.def_static("squaredChordLengthFor", &Circle::squaredChordLengthFor,
                   "openingAngle"_a);
    cls.def_static("openingAngleFor", &Circle::openingAngleFor,
                   "squaredChordLength"_a);
 
    cls.def(py::init<>());
    cls.def(py::init<UnitVector3d const &>(), "center"_a);
    cls.def(py::init<UnitVector3d const &, Angle>(), "center"_a, "angle"_a);
    cls.def(py::init<UnitVector3d const &, double>(), "center"_a,
            "squaredChordLength"_a);
    cls.def(py::init<Circle const &>(), "circle"_a);
 
    cls.def("__eq__", &Circle::operator==, py::is_operator());
    cls.def("__ne__", &Circle::operator!=, py::is_operator());
    cls.def("__contains__",
            (bool (Circle::*)(Circle const &) const) & Circle::contains,
            py::is_operator());
    // Rewrap this base class method since there are overloads in this subclass
    cls.def("__contains__",
            (bool (Circle::*)(UnitVector3d const &) const) & Circle::contains,
            py::is_operator());
 
    cls.def("isFull", &Circle::isFull);
    cls.def("getCenter", &Circle::getCenter);
    cls.def("getSquaredChordLength", &Circle::getSquaredChordLength);
    cls.def("getOpeningAngle", &Circle::getOpeningAngle);
    cls.def("contains",
            (bool (Circle::*)(Circle const &) const) & Circle::contains);
    // Rewrap these base class methods since there are overloads in this subclass
    cls.def("contains",
            (bool (Circle::*)(UnitVector3d const &) const) & Circle::contains);
    cls.def("contains", py::vectorize((bool (Circle::*)(double, double, double) const)&Circle::contains),
            "x"_a, "y"_a, "z"_a);
    cls.def("contains", py::vectorize((bool (Circle::*)(double, double) const)&Circle::contains),
            "lon"_a, "lat"_a);
 
    cls.def("isDisjointFrom",
            (bool (Circle::*)(UnitVector3d const &) const) &
                    Circle::isDisjointFrom);
    cls.def("isDisjointFrom",
            (bool (Circle::*)(Circle const &) const) & Circle::isDisjointFrom);
    cls.def("intersects",
            (bool (Circle::*)(UnitVector3d const &) const) &
                    Circle::intersects);
    cls.def("intersects",
            (bool (Circle::*)(Circle const &) const) & Circle::intersects);
    cls.def("isWithin",
            (bool (Circle::*)(UnitVector3d const &) const) & Circle::isWithin);
    cls.def("isWithin",
            (bool (Circle::*)(Circle const &) const) & Circle::isWithin);
    cls.def("clipTo",
            (Circle & (Circle::*)(UnitVector3d const &)) & Circle::clipTo);
    cls.def("clipTo", (Circle & (Circle::*)(Circle const &)) & Circle::clipTo);
    cls.def("clippedTo",
            (Circle(Circle::*)(UnitVector3d const &) const) &
                    Circle::clippedTo);
    cls.def("clippedTo",
            (Circle(Circle::*)(Circle const &) const) & Circle::clippedTo);
    cls.def("expandTo",
            (Circle & (Circle::*)(UnitVector3d const &)) & Circle::expandTo);
    cls.def("expandTo",
            (Circle & (Circle::*)(Circle const &)) & Circle::expandTo);
    cls.def("expandedTo",
            (Circle(Circle::*)(UnitVector3d const &) const) &
                    Circle::expandedTo);
    cls.def("expandedTo",
            (Circle(Circle::*)(Circle const &) const) & Circle::expandedTo);
    cls.def("dilateBy", &Circle::dilateBy, "radius"_a);
    cls.def("dilatedBy", &Circle::dilatedBy, "radius"_a);
    cls.def("erodeBy", &Circle::erodeBy, "radius"_a);
    cls.def("erodedBy", &Circle::erodedBy, "radius"_a);
    cls.def("getArea", &Circle::getArea);
    cls.def("complement", &Circle::complement);
    cls.def("complemented", &Circle::complemented);
 
    // Note that the Region interface has already been wrapped.
 
    cls.def("__str__", [](Circle const &self) {
        return py::str("Circle({!s}, {!s})")
                .format(self.getCenter(), self.getOpeningAngle());
    });
    cls.def("__repr__", [](Circle const &self) {
        return py::str("Circle({!r}, {!r})")
                .format(self.getCenter(), self.getOpeningAngle());
    });
    cls.def(py::pickle(&python::encode, &python::decode<Circle>));
}

defineClass() [7/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< CompoundRegion, std::unique_ptr< CompoundRegion >, Region > &

cls

)

Definition at line 94 of file _compoundRegion.cc.

                                                                                       {
    cls.def("nOperands", &CompoundRegion::nOperands);
    cls.def("__len__", &CompoundRegion::nOperands);
    cls.def(
        "__iter__",
        [](CompoundRegion const& region) {
            return py::make_iterator(
                CompoundIterator(region, 0U), CompoundIterator(region, region.nOperands())
            );
        },
        py::return_value_policy::reference_internal  // Keeps region alive while iterator is in use.
    );
    cls.def(
        "cloneOperand",
        [](CompoundRegion const &self, std::ptrdiff_t n) {
            int nOperands = self.nOperands();
            return self.getOperand(python::convertIndex(nOperands, n)).clone();
        }
    );
}

defineClass() [8/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< ConvexPolygon, std::unique_ptr< ConvexPolygon >, Region > &

cls

)

Definition at line 52 of file _convexPolygon.cc.

                                          {
    cls.attr("TYPE_CODE") = py::int_(ConvexPolygon::TYPE_CODE);
 
    cls.def_static("convexHull", &ConvexPolygon::convexHull, "points"_a);
 
    cls.def(py::init<std::vector<UnitVector3d> const &>(), "points"_a);
    // Do not wrap the two unsafe (3 and 4 vertex) constructors
    cls.def(py::init<ConvexPolygon const &>(), "convexPolygon"_a);
 
    cls.def("__eq__", &ConvexPolygon::operator==, py::is_operator());
    cls.def("__ne__", &ConvexPolygon::operator!=, py::is_operator());
 
    cls.def("getVertices", &ConvexPolygon::getVertices);
    cls.def("getCentroid", &ConvexPolygon::getCentroid);
 
    // Note that much of the Region interface has already been wrapped. Here are bits that have not:
    // (include overloads from Region that would otherwise be shadowed).
    cls.def("contains", py::overload_cast<UnitVector3d const &>(&ConvexPolygon::contains, py::const_));
    cls.def("contains", py::overload_cast<Region const &>(&ConvexPolygon::contains, py::const_));
    cls.def("contains",
            py::vectorize((bool (ConvexPolygon::*)(double, double, double) const)&ConvexPolygon::contains),
            "x"_a, "y"_a, "z"_a);
    cls.def("contains",
            py::vectorize((bool (ConvexPolygon::*)(double, double) const)&ConvexPolygon::contains),
            "lon"_a, "lat"_a);
    cls.def("isDisjointFrom", &ConvexPolygon::isDisjointFrom);
    cls.def("intersects", &ConvexPolygon::intersects);
    cls.def("isWithin", &ConvexPolygon::isWithin);
 
    cls.def("__repr__", [](ConvexPolygon const &self) {
        return py::str("ConvexPolygon({!r})").format(self.getVertices());
    });
    cls.def(py::pickle(&python::encode, &python::decode<ConvexPolygon>));
}

defineClass() [9/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Ellipse, std::unique_ptr< Ellipse >, Region > &

cls

)

Definition at line 51 of file _ellipse.cc.

                                                                         {
    cls.attr("TYPE_CODE") = py::int_(Ellipse::TYPE_CODE);
 
    cls.def_static("empty", &Ellipse::empty);
    cls.def_static("full", &Ellipse::full);
 
    cls.def(py::init<>());
    cls.def(py::init<Circle const &>(), "circle"_a);
    cls.def(py::init<UnitVector3d const &, Angle>(), "center"_a,
            "angle"_a = Angle(0.0));
    cls.def(py::init<UnitVector3d const &, UnitVector3d const &, Angle>(),
            "focus1"_a, "focus2"_a, "alpha"_a);
    cls.def(py::init<UnitVector3d const &, Angle, Angle, Angle>(), "center"_a,
            "alpha"_a, "beta"_a, "orientation"_a);
    cls.def(py::init<Ellipse const &>(), "ellipse"_a);
 
    cls.def("__eq__", &Ellipse::operator==, py::is_operator());
    cls.def("__ne__", &Ellipse::operator!=, py::is_operator());
 
    cls.def("isFull", &Ellipse::isFull);
    cls.def("isGreatCircle", &Ellipse::isGreatCircle);
    cls.def("isCircle", &Ellipse::isCircle);
    cls.def("getTransformMatrix", &Ellipse::getTransformMatrix);
    cls.def("getCenter", &Ellipse::getCenter);
    cls.def("getF1", &Ellipse::getF1);
    cls.def("getF2", &Ellipse::getF2);
    cls.def("getAlpha", &Ellipse::getAlpha);
    cls.def("getBeta", &Ellipse::getBeta);
    cls.def("getGamma", &Ellipse::getGamma);
    cls.def("complement", &Ellipse::complement);
    cls.def("complemented", &Ellipse::complemented);
 
    // Note that the Region interface has already been wrapped.
 
    cls.def("__str__", [](Ellipse const &self) {
        return py::str("Ellipse({!s}, {!s}, {!s})")
                .format(self.getF1(), self.getF2(), self.getAlpha());
    });
    cls.def("__repr__", [](Ellipse const &self) {
        return py::str("Ellipse({!r}, {!r}, {!r})")
                .format(self.getF1(), self.getF2(), self.getAlpha());
    });
    cls.def(py::pickle(&python::encode, &python::decode<Ellipse>));
}

defineClass() [10/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< HtmPixelization, Pixelization > &

cls

)

Definition at line 42 of file _htmPixelization.cc.

                                                               {
    cls.attr("MAX_LEVEL") = py::int_(HtmPixelization::MAX_LEVEL);
 
    cls.def_static("level", &HtmPixelization::level, "i"_a);
    cls.def_static("triangle", &HtmPixelization::triangle, "i"_a);
    cls.def_static("asString", &HtmPixelization::asString, "i"_a);
 
    cls.def(py::init<int>(), "level"_a);
    cls.def(py::init<HtmPixelization const &>(), "htmPixelization"_a);
 
    cls.def("getLevel", &HtmPixelization::getLevel);
 
    cls.def("__eq__",
            [](HtmPixelization const &self, HtmPixelization const &other) {
                return self.getLevel() == other.getLevel();
            });
    cls.def("__ne__",
            [](HtmPixelization const &self, HtmPixelization const &other) {
                return self.getLevel() != other.getLevel();
            });
    cls.def("__repr__", [](HtmPixelization const &self) {
        return py::str("HtmPixelization({!s})").format(self.getLevel());
    });
    cls.def("__reduce__", [cls](HtmPixelization const &self) {
        return py::make_tuple(cls, py::make_tuple(self.getLevel()));
    });
}

defineClass() [11/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< IntersectionRegion, std::unique_ptr< IntersectionRegion >, CompoundRegion > &

cls

)

Definition at line 124 of file _compoundRegion.cc.

                                                                                                       {
    cls.attr("TYPE_CODE") = py::int_(IntersectionRegion::TYPE_CODE);
    cls.def(py::init(&_args_factory<IntersectionRegion>));
    cls.def(py::pickle(&python::encode, &python::decode<IntersectionRegion>));
    cls.def("__repr__", [](CompoundRegion const &self) { return _repr("IntersectionRegion", self); });
}

defineClass() [12/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Interval1d, std::shared_ptr< Interval1d > > &

cls

)

Definition at line 43 of file _interval1d.cc.

                                                                       {
    python::defineInterval<decltype(cls), Interval1d, double>(cls);
 
    cls.def_static("empty", &Interval1d::empty);
    cls.def_static("full", &Interval1d::full);
 
    cls.def(py::init<>());
    cls.def(py::init<double>(), "x"_a);
    cls.def(py::init<double, double>(), "x"_a, "y"_a);
    cls.def(py::init<Interval1d const &>(), "interval"_a);
 
    cls.def("isFull", &Interval1d::isFull);
 
    cls.def("__str__", [](Interval1d const &self) {
        return py::str("[{!s}, {!s}]").format(self.getA(), self.getB());
    });
    cls.def("__repr__", [](Interval1d const &self) {
        return py::str("Interval1d({!r}, {!r})")
                .format(self.getA(), self.getB());
    });
}

defineClass() [13/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< LonLat, std::shared_ptr< LonLat > > &

cls

)

Definition at line 43 of file _lonLat.cc.

                                                               {
    cls.def_static("fromDegrees", &LonLat::fromDegrees);
    cls.def_static("fromRadians", &LonLat::fromRadians);
    cls.def_static("latitudeOf", &LonLat::latitudeOf);
    cls.def_static("longitudeOf", &LonLat::longitudeOf);
 
    cls.def(py::init<>());
    cls.def(py::init<LonLat const &>());
    cls.def(py::init<NormalizedAngle, Angle>(), "lon"_a, "lat"_a);
    cls.def(py::init<Vector3d const &>(), "vector"_a);
 
    cls.def("__eq__", &LonLat::operator==, py::is_operator());
    cls.def("__nq__", &LonLat::operator!=, py::is_operator());
 
    cls.def("getLon", &LonLat::getLon);
    cls.def("getLat", &LonLat::getLat);
 
    cls.def("__len__", [](LonLat const &self) { return py::int_(2); });
    cls.def("__getitem__", [](LonLat const &self, py::object key) {
        auto t = py::make_tuple(self.getLon(), self.getLat());
        return t.attr("__getitem__")(key);
    });
    cls.def("__iter__", [](LonLat const &self) {
        auto t = py::make_tuple(self.getLon(), self.getLat());
        return t.attr("__iter__")();
    });
 
    cls.def("__str__", [](LonLat const &self) {
        return py::str("[{!s}, {!s}]")
                .format(self.getLon().asRadians(), self.getLat().asRadians());
    });
    cls.def("__repr__", [](LonLat const &self) {
        return py::str("LonLat.fromRadians({!r}, {!r})")
                .format(self.getLon().asRadians(), self.getLat().asRadians());
    });
    cls.def("__reduce__", [cls](LonLat const &self) {
        return py::make_tuple(cls,
                              py::make_tuple(self.getLon(), self.getLat()));
    });
}

defineClass() [14/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Matrix3d, std::shared_ptr< Matrix3d > > &

cls

)

Definition at line 49 of file _matrix3d.cc.

                                                                   {
    cls.def(py::init<>());
    cls.def(py::init<double, double, double, double, double, double, double,
                     double, double>(),
            "m00"_a, "m01"_a, "m02"_a, "m10"_a, "m11"_a, "m12"_a, "m20"_a,
            "m21"_a, "m22"_a);
    cls.def(py::init<Vector3d const &>(), "diagonal"_a);
    cls.def(py::init<double>(), "scale"_a);
    cls.def(py::init<Matrix3d const &>(), "matrix"_a);
 
    cls.def("__eq__", &Matrix3d::operator==, py::is_operator());
    cls.def("__ne__", &Matrix3d::operator!=, py::is_operator());
 
    // Add bounds checking to getRow and getColumn
    cls.def("getRow", &getRow, "row"_a);
    cls.def("getColumn",
            [](Matrix3d const &self, py::int_ col) {
                return self.getColumn(
                        static_cast<int>(python::convertIndex(3, col)));
            },
            "col"_a);
 
    cls.def("__len__", [](Matrix3d const &self) { return py::int_(3); });
    cls.def("__getitem__", &getRow, py::is_operator());
    cls.def("__getitem__",
            [](Matrix3d const &self, py::tuple t) {
                if (t.size() > 2) {
                    throw py::index_error("Too many indexes for Matrix3d");
                } else if (t.size() == 0) {
                    return py::cast(self);
                } else if (t.size() == 1) {
                    return py::cast(getRow(self, t[0].cast<py::int_>()));
                }
                return py::cast(
                        self(python::convertIndex(3, t[0].cast<py::int_>()),
                             python::convertIndex(3, t[1].cast<py::int_>())));
            },
            py::is_operator());
 
    cls.def("inner", &Matrix3d::inner, "matrix"_a);
    cls.def("getSquaredNorm", &Matrix3d::getSquaredNorm);
    cls.def("getNorm", &Matrix3d::getNorm);
 
    cls.def("__mul__",
            (Vector3d(Matrix3d::*)(Vector3d const &) const) &
                    Matrix3d::operator*,
            "vector"_a, py::is_operator());
    cls.def("__mul__",
            (Matrix3d(Matrix3d::*)(Matrix3d const &) const) &
                    Matrix3d::operator*,
            "matrix"_a, py::is_operator());
    cls.def("__add__", &Matrix3d::operator+, py::is_operator());
    cls.def("__sub__", &Matrix3d::operator-, py::is_operator());
 
    cls.def("cwiseProduct", &Matrix3d::cwiseProduct);
    cls.def("transpose", &Matrix3d::transpose);
    cls.def("inverse", &Matrix3d::inverse);
 
    cls.def("__str__", [](Matrix3d const &self) {
        return py::str("[[{!s}, {!s}, {!s}],\n"
                       " [{!s}, {!s}, {!s}],\n"
                       " [{!s}, {!s}, {!s}]]")
                .format(self(0, 0), self(0, 1), self(0, 2), self(1, 0),
                        self(1, 1), self(1, 2), self(2, 0), self(2, 1),
                        self(2, 2));
    });
    cls.def("__repr__", [](Matrix3d const &self) {
        return py::str("Matrix3d({!r}, {!r}, {!r},\n"
                       "         {!r}, {!r}, {!r},\n"
                       "         {!r}, {!r}, {!r})")
                .format(self(0, 0), self(0, 1), self(0, 2), self(1, 0),
                        self(1, 1), self(1, 2), self(2, 0), self(2, 1),
                        self(2, 2));
    });
    cls.def("__reduce__", [cls](Matrix3d const &self) {
        auto args = py::make_tuple(self(0, 0), self(0, 1), self(0, 2),
                                   self(1, 0), self(1, 1), self(1, 2),
                                   self(2, 0), self(2, 1), self(2, 2));
        return py::make_tuple(cls, args);
    });
}

defineClass() [15/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Mq3cPixelization, Pixelization > &

cls

)

Definition at line 42 of file _mq3cPixelization.cc.

                                                                {
    cls.attr("MAX_LEVEL") = py::int_(Mq3cPixelization::MAX_LEVEL);
 
    cls.def_static("level", &Mq3cPixelization::level);
    cls.def_static("quad", &Mq3cPixelization::quad);
    cls.def_static("neighborhood", &Mq3cPixelization::neighborhood);
    cls.def_static("asString", &Mq3cPixelization::asString);
 
    cls.def(py::init<int>(), "level"_a);
    cls.def(py::init<Mq3cPixelization const &>(), "mq3cPixelization"_a);
 
    cls.def("getLevel", &Mq3cPixelization::getLevel);
 
    cls.def("__eq__",
            [](Mq3cPixelization const &self, Mq3cPixelization const &other) {
                return self.getLevel() == other.getLevel();
            });
    cls.def("__ne__",
            [](Mq3cPixelization const &self, Mq3cPixelization const &other) {
                return self.getLevel() != other.getLevel();
            });
    cls.def("__repr__", [](Mq3cPixelization const &self) {
        return py::str("Mq3cPixelization({!s})").format(self.getLevel());
    });
    cls.def("__reduce__", [cls](Mq3cPixelization const &self) {
        return py::make_tuple(cls, py::make_tuple(self.getLevel()));
    });
}

defineClass() [16/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< NormalizedAngle > &

cls

)

Definition at line 44 of file _normalizedAngle.cc.

                                                 {
    // Provide the equivalent of the NormalizedAngle to Angle C++ cast
    // operator in Python
    py::implicitly_convertible<NormalizedAngle, Angle>();
 
    cls.def_static("nan", &NormalizedAngle::nan);
    cls.def_static("fromDegrees", &NormalizedAngle::fromDegrees);
    cls.def_static("fromRadians", &NormalizedAngle::fromRadians);
    cls.def_static("between", &NormalizedAngle::between, "a"_a, "b"_a);
    cls.def_static("center", &NormalizedAngle::center, "a"_a, "b"_a);
 
    cls.def(py::init<>());
    cls.def(py::init<NormalizedAngle const &>());
    cls.def(py::init<Angle const &>());
    cls.def(py::init<double>(), "radians"_a);
    cls.def(py::init<LonLat const &, LonLat const &>(), "a"_a, "b"_a);
    cls.def(py::init<Vector3d const &, Vector3d const &>(), "a"_a, "b"_a);
 
    cls.def("__eq__", &NormalizedAngle::operator==, py::is_operator());
    cls.def("__ne__", &NormalizedAngle::operator!=, py::is_operator());
    cls.def("__lt__", &NormalizedAngle::operator<, py::is_operator());
    cls.def("__gt__", &NormalizedAngle::operator>, py::is_operator());
    cls.def("__le__", &NormalizedAngle::operator<=, py::is_operator());
    cls.def("__ge__", &NormalizedAngle::operator>=, py::is_operator());
 
    cls.def("__neg__",
            (Angle(NormalizedAngle::*)() const) & NormalizedAngle::operator-);
    cls.def("__add__", &NormalizedAngle::operator+, py::is_operator());
    cls.def("__sub__",
            (Angle(NormalizedAngle::*)(Angle const &) const) &
                    NormalizedAngle::operator-,
            py::is_operator());
    cls.def("__mul__", &NormalizedAngle::operator*, py::is_operator());
    cls.def("__rmul__", &NormalizedAngle::operator*, py::is_operator());
    cls.def("__truediv__",
            (Angle(NormalizedAngle::*)(double) const) &
                    NormalizedAngle::operator/,
            py::is_operator());
    cls.def("__truediv__",
            (double (NormalizedAngle::*)(Angle const &) const) &
                    NormalizedAngle::operator/,
            py::is_operator());
 
    cls.def("asDegrees", &NormalizedAngle::asDegrees);
    cls.def("asRadians", &NormalizedAngle::asRadians);
    cls.def("isNan", &NormalizedAngle::isNan);
    cls.def("getAngleTo", &NormalizedAngle::getAngleTo);
 
    cls.def("__str__", [](NormalizedAngle const &self) {
        return py::str("{!s}").format(self.asRadians());
    });
    cls.def("__repr__", [](NormalizedAngle const &self) {
        return py::str("NormalizedAngle({!r})").format(self.asRadians());
    });
 
    cls.def("__reduce__", [cls](NormalizedAngle const &self) {
        return py::make_tuple(cls, py::make_tuple(self.asRadians()));
    });
}

defineClass() [17/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< NormalizedAngleInterval, std::shared_ptr< NormalizedAngleInterval > > &

cls

)

Definition at line 43 of file _normalizedAngleInterval.cc.

                                                                          {
    python::defineInterval<decltype(cls), NormalizedAngleInterval,
                           NormalizedAngle>(cls);
 
    cls.def_static("fromDegrees", &NormalizedAngleInterval::fromDegrees, "x"_a,
                   "y"_a);
    cls.def_static("fromRadians", &NormalizedAngleInterval::fromRadians, "x"_a,
                   "y"_a);
    cls.def_static("empty", &NormalizedAngleInterval::empty);
    cls.def_static("full", &NormalizedAngleInterval::full);
 
    cls.def(py::init<>());
    cls.def(py::init<Angle>(), "x"_a);
    cls.def(py::init<NormalizedAngle>(), "x"_a);
    cls.def(py::init<Angle, Angle>(), "x"_a, "y"_a);
    cls.def(py::init<NormalizedAngle, NormalizedAngle>(), "x"_a, "y"_a);
    cls.def(py::init<NormalizedAngleInterval const &>(), "angleInterval"_a);
 
    cls.def("isEmpty", &NormalizedAngleInterval::isEmpty);
    cls.def("isFull", &NormalizedAngleInterval::isFull);
    cls.def("wraps", &NormalizedAngleInterval::wraps);
 
    cls.def("__str__", [](NormalizedAngleInterval const &self) {
        return py::str("[{!s}, {!s}]")
                .format(self.getA().asRadians(), self.getB().asRadians());
    });
    cls.def("__repr__", [](NormalizedAngleInterval const &self) {
        return py::str("NormalizedAngleInterval.fromRadians({!r},"
                       " {!r})")
                .format(self.getA().asRadians(), self.getB().asRadians());
    });
}

defineClass() [18/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Pixelization > &

cls

)

Definition at line 44 of file _pixelization.cc.

                                              {
    cls.def("universe", &Pixelization::universe);
    cls.def("pixel", &Pixelization::pixel, "i"_a);
    cls.def("index", &Pixelization::index, "i"_a);
    cls.def("toString", &Pixelization::toString, "i"_a);
    cls.def("envelope", &Pixelization::envelope, "region"_a, "maxRanges"_a = 0);
    cls.def("interior", &Pixelization::interior, "region"_a, "maxRanges"_a = 0);
}

defineClass() [19/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Q3cPixelization, Pixelization > &

cls

)

Definition at line 42 of file _q3cPixelization.cc.

                                                               {
    cls.attr("MAX_LEVEL") = py::int_(Q3cPixelization::MAX_LEVEL);
 
    cls.def(py::init<int>(), "level"_a);
    cls.def(py::init<Q3cPixelization const &>(), "q3cPixelization"_a);
 
    cls.def("getLevel", &Q3cPixelization::getLevel);
    cls.def("quad", &Q3cPixelization::quad);
    cls.def("neighborhood", &Q3cPixelization::neighborhood);
 
    cls.def("__eq__",
            [](Q3cPixelization const &self, Q3cPixelization const &other) {
                return self.getLevel() == other.getLevel();
            });
    cls.def("__ne__",
            [](Q3cPixelization const &self, Q3cPixelization const &other) {
                return self.getLevel() != other.getLevel();
            });
    cls.def("__repr__", [](Q3cPixelization const &self) {
        return py::str("Q3cPixelization({!s})").format(self.getLevel());
    });
    cls.def("__reduce__", [cls](Q3cPixelization const &self) {
        return py::make_tuple(cls, py::make_tuple(self.getLevel()));
    });
}

defineClass() [20/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< RangeSet, std::shared_ptr< RangeSet > > &

cls

)

Definition at line 94 of file _rangeSet.cc.

                                                                   {
    cls.def(py::init<>());
    cls.def(py::init<uint64_t>(), "integer"_a);
    cls.def(py::init([](uint64_t a, uint64_t b) {
                return new RangeSet(a, b);
            }),
            "first"_a, "last"_a);
    cls.def(py::init<RangeSet const &>(), "rangeSet"_a);
    cls.def(py::init(
            [](py::iterable iterable) {
                return new RangeSet(makeRangeSet(iterable));
            }),
            "iterable"_a);
    cls.def("__eq__", &RangeSet::operator==, py::is_operator());
    cls.def("__ne__", &RangeSet::operator!=, py::is_operator());
 
    cls.def("insert", (void (RangeSet::*)(uint64_t)) & RangeSet::insert,
            "integer"_a);
    cls.def("insert",
            (void (RangeSet::*)(uint64_t, uint64_t)) & RangeSet::insert,
            "first"_a, "last"_a);
    cls.def("erase", (void (RangeSet::*)(uint64_t)) & RangeSet::erase,
            "integer"_a);
    cls.def("erase", (void (RangeSet::*)(uint64_t, uint64_t)) & RangeSet::erase,
            "first"_a, "last"_a);
 
    cls.def("complement", &RangeSet::complement);
    cls.def("complemented", &RangeSet::complemented);
    cls.def("intersection", &RangeSet::intersection, "rangeSet"_a);
    // In C++, the set union function is named join because union is a keyword.
    // Python does not suffer from the same restriction.
    cls.def("union", &RangeSet::join, "rangeSet"_a);
    cls.def("difference", &RangeSet::difference, "rangeSet"_a);
    cls.def("symmetricDifference", &RangeSet::symmetricDifference,
            "rangeSet"_a);
    cls.def("__invert__", &RangeSet::operator~, py::is_operator());
    cls.def("__and__", &RangeSet::operator&, py::is_operator());
    cls.def("__or__", &RangeSet::operator|, py::is_operator());
    cls.def("__sub__", &RangeSet::operator-, py::is_operator());
    cls.def("__xor__", &RangeSet::operator^, py::is_operator());
    cls.def("__iand__", &RangeSet::operator&=);
    cls.def("__ior__", &RangeSet::operator|=);
    cls.def("__isub__", &RangeSet::operator-=);
    cls.def("__ixor__", &RangeSet::operator^=);
 
    cls.def("__len__", &RangeSet::size);
    cls.def("__getitem__", [](RangeSet const &self, py::int_ i) {
        auto j = python::convertIndex(static_cast<ptrdiff_t>(self.size()), i);
        return py::cast(self.begin()[j]);
    });
 
    cls.def("intersects",
            (bool (RangeSet::*)(uint64_t) const) & RangeSet::intersects,
            "integer"_a);
    cls.def("intersects",
            (bool (RangeSet::*)(uint64_t, uint64_t) const) &
                    RangeSet::intersects,
            "first"_a, "last"_a);
    cls.def("intersects",
            (bool (RangeSet::*)(RangeSet const &) const) & RangeSet::intersects,
            "rangeSet"_a);
 
    cls.def("contains",
            (bool (RangeSet::*)(uint64_t) const) & RangeSet::contains,
            "integer"_a);
    cls.def("contains",
            (bool (RangeSet::*)(uint64_t, uint64_t) const) & RangeSet::contains,
            "first"_a, "last"_a);
    cls.def("contains",
            (bool (RangeSet::*)(RangeSet const &) const) & RangeSet::contains,
            "rangeSet"_a);
    cls.def("__contains__",
            (bool (RangeSet::*)(uint64_t) const) & RangeSet::contains,
            "integer"_a, py::is_operator());
    cls.def("__contains__",
            (bool (RangeSet::*)(uint64_t, uint64_t) const) & RangeSet::contains,
            "first"_a, "last"_a, py::is_operator());
    cls.def("__contains__",
            (bool (RangeSet::*)(RangeSet const &) const) & RangeSet::contains,
            "rangeSet"_a, py::is_operator());
 
    cls.def("isWithin",
            (bool (RangeSet::*)(uint64_t) const) & RangeSet::isWithin,
            "integer"_a);
    cls.def("isWithin",
            (bool (RangeSet::*)(uint64_t, uint64_t) const) & RangeSet::isWithin,
            "first"_a, "last"_a);
    cls.def("isWithin",
            (bool (RangeSet::*)(RangeSet const &) const) & RangeSet::isWithin,
            "rangeSet"_a);
 
    cls.def("isDisjointFrom",
            (bool (RangeSet::*)(uint64_t) const) & RangeSet::isDisjointFrom,
            "integer"_a);
    cls.def("isDisjointFrom",
            (bool (RangeSet::*)(uint64_t, uint64_t) const) &
                    RangeSet::isDisjointFrom,
            "first"_a, "last"_a);
    cls.def("isDisjointFrom",
            (bool (RangeSet::*)(RangeSet const &) const) &
                    RangeSet::isDisjointFrom,
            "rangeSet"_a);
 
    cls.def("simplify", &RangeSet::simplify, "n"_a);
    cls.def("simplified", &RangeSet::simplified, "n"_a);
    cls.def("scale", &RangeSet::scale, "factor"_a);
    cls.def("scaled", &RangeSet::scaled, "factor"_a);
    cls.def("fill", &RangeSet::fill);
    cls.def("clear", &RangeSet::clear);
    cls.def("empty", &RangeSet::empty);
    cls.def("full", &RangeSet::full);
    cls.def("size", &RangeSet::size);
    cls.def("cardinality", &RangeSet::cardinality);
    // max_size() and swap() are omitted. The former is a C++ container
    // requirement, and the latter doesn't seem relevant to Python.
    cls.def("isValid", &RangeSet::cardinality);
    cls.def("ranges", &ranges);
 
    cls.def("__str__",
            [](RangeSet const &self) { return py::str(ranges(self)); });
    cls.def("__repr__", [](RangeSet const &self) {
        return py::str("RangeSet({!s})").format(ranges(self));
    });
 
    cls.def("__reduce__", [cls](RangeSet const &self) {
        return py::make_tuple(cls, py::make_tuple(ranges(self)));
    });
}

defineClass() [21/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Region, std::unique_ptr< Region > > &

cls

)

Definition at line 54 of file _region.cc.

                                                               {
    cls.def("clone", &Region::clone);
    cls.def("isEmpty", &Region::isEmpty);
    cls.def("getBoundingBox", &Region::getBoundingBox);
    cls.def("getBoundingBox3d", &Region::getBoundingBox3d);
    cls.def("getBoundingCircle", &Region::getBoundingCircle);
    cls.def("contains", py::overload_cast<UnitVector3d const &>(&Region::contains, py::const_),
            "unitVector"_a);
    cls.def("contains", py::vectorize((bool (Region::*)(double, double, double) const)&Region::contains),
            "x"_a, "y"_a, "z"_a);
    cls.def("contains", py::vectorize((bool (Region::*)(double, double) const)&Region::contains),
            "lon"_a, "lat"_a);
    cls.def("__contains__", py::overload_cast<UnitVector3d const &>(&Region::contains, py::const_),
            py::is_operator());
    // The per-subclass relate() overloads are used to implement
    // double-dispatch in C++, and are not needed in Python.
    cls.def("relate",
            (Relationship(Region::*)(Region const &) const) & Region::relate,
            "region"_a);
    cls.def("overlaps",
            (TriState(Region::*)(Region const &) const)&Region::overlaps,
            "region"_a);
    cls.def("encode", &python::encode);
    cls.def_static("decode", &python::decode<Region>, "bytes"_a);
    cls.def_static("decodeBase64", py::overload_cast<std::string_view const&>(&Region::decodeBase64),
                   "bytes"_a);
    cls.def_static("decodeOverlapsBase64",
                    py::overload_cast<std::string_view const&>(&Region::decodeOverlapsBase64),
                   "bytes"_a);
    cls.def_static("getRegions", Region::getRegions, "region"_a);
}

defineClass() [22/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< UnionRegion, std::unique_ptr< UnionRegion >, CompoundRegion > &

cls

)

Definition at line 116 of file _compoundRegion.cc.

                                                                                         {
    cls.attr("TYPE_CODE") = py::int_(UnionRegion::TYPE_CODE);
    cls.def(py::init(&_args_factory<UnionRegion>));
    cls.def(py::pickle(&python::encode, &python::decode<UnionRegion>));
    cls.def("__repr__", [](CompoundRegion const &self) { return _repr("UnionRegion", self); });
}

defineClass() [23/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< UnitVector3d, std::shared_ptr< UnitVector3d > > &

cls

)

Definition at line 46 of file _unitVector3d.cc.

                                                                           {
    // Provide the equivalent of the UnitVector3d to Vector3d C++ cast
    // operator in Python
    py::implicitly_convertible<UnitVector3d, Vector3d>();
 
    cls.def_static(
            "orthogonalTo",
            (UnitVector3d(*)(Vector3d const &)) & UnitVector3d::orthogonalTo,
            "vector"_a);
    cls.def_static("orthogonalTo",
                   (UnitVector3d(*)(Vector3d const &, Vector3d const &)) &
                           UnitVector3d::orthogonalTo,
                   "vector1"_a, "vector2"_a);
    cls.def_static("orthogonalTo",
                   (UnitVector3d(*)(NormalizedAngle const &)) &
                           UnitVector3d::orthogonalTo,
                   "meridian"_a);
    cls.def_static("northFrom", &UnitVector3d::northFrom, "vector"_a);
    cls.def_static("X", &UnitVector3d::X);
    cls.def_static("Y", &UnitVector3d::Y);
    cls.def_static("Z", &UnitVector3d::Z);
    // The fromNormalized static factory functions are not exposed to
    // Python, as they are easy to misuse and intended only for performance
    // critical code (i.e. not Python).
 
    cls.def(py::init<>());
    cls.def(py::init<UnitVector3d const &>(), "unitVector"_a);
    cls.def(py::init<Vector3d const &>(), "vector"_a);
    cls.def(py::init<double, double, double>(), "x"_a, "y"_a, "z"_a);
    cls.def(py::init<LonLat const &>(), "lonLat"_a);
    cls.def(py::init<Angle, Angle>(), "lon"_a, "lat"_a);
 
    cls.def("__eq__", &UnitVector3d::operator==, py::is_operator());
    cls.def("__ne__", &UnitVector3d::operator!=, py::is_operator());
    cls.def("__neg__",
            (UnitVector3d(UnitVector3d::*)() const) & UnitVector3d::operator-);
    cls.def("__add__", &UnitVector3d::operator+, py::is_operator());
    cls.def("__sub__",
            (Vector3d(UnitVector3d::*)(Vector3d const &) const) &
                    UnitVector3d::operator-,
            py::is_operator());
    cls.def("__mul__", &UnitVector3d::operator*, py::is_operator());
    cls.def("__truediv__", &UnitVector3d::operator/, py::is_operator());
 
    cls.def("x", &UnitVector3d::x);
    cls.def("y", &UnitVector3d::y);
    cls.def("z", &UnitVector3d::z);
    cls.def("x", &UnitVector3d::dot);
    cls.def("dot", &UnitVector3d::dot);
    cls.def("cross", &UnitVector3d::cross);
    cls.def("robustCross", &UnitVector3d::robustCross);
    cls.def("cwiseProduct", &UnitVector3d::cwiseProduct);
    cls.def("rotatedAround", &UnitVector3d::rotatedAround, "axis"_a, "angle"_a);
 
    cls.def("__len__", [](UnitVector3d const &self) { return py::int_(3); });
    cls.def("__getitem__", [](UnitVector3d const &self, py::int_ i) {
        return self(python::convertIndex(3, i));
    });
 
    cls.def("__str__", [](UnitVector3d const &self) {
        return py::str("[{!s}, {!s}, {!s}]")
                .format(self.x(), self.y(), self.z());
    });
    cls.def("__repr__", [](UnitVector3d const &self) {
        return py::str("UnitVector3d({!r}, {!r}, {!r})")
                .format(self.x(), self.y(), self.z());
    });
 
    // Do not implement __reduce__ for pickling. Why? Given:
    //
    //    u = UnitVector3d(x, y, z)
    //    v = UnitVector3d(u.x(), u.y(), u.z())
    //
    // u may not be identical to v, since the constructor normalizes its input
    // components. Furthermore, UnitVector3d::fromNormalized is not visible to
    // Python, and even if it were, pybind11 is currently incapable of returning
    // a picklable reference to it.
    cls.def(py::pickle([](UnitVector3d const &self) { return py::make_tuple(self.x(), self.y(), self.z()); },
                       [](py::tuple t) {
                           if (t.size() != 3) {
                               throw std::runtime_error("Tuple size = " + std::to_string(t.size()) +
                                                        "; must be 3 for a UnitVector3d");
                           }
                           return new UnitVector3d(UnitVector3d::fromNormalized(
                                   t[0].cast<double>(), t[1].cast<double>(), t[2].cast<double>()));
                       }));
}

defineClass() [24/25]

template<>

void lsst::sphgeom::defineClass

(

py::class_< Vector3d, std::shared_ptr< Vector3d > > &

cls

)

Definition at line 45 of file _vector3d.cc.

                                                                   {
    cls.def(py::init<>());
    cls.def(py::init<double, double, double>(), "x"_a, "y"_a, "z"_a);
    cls.def(py::init<Vector3d const &>(), "vector"_a);
    // Construct a Vector3d from a UnitVector3d, enabling implicit
    // conversion from UnitVector3d to Vector3d in python via
    // py::implicitly_convertible
    cls.def(py::init([](UnitVector3d const &u) {
        return new Vector3d(u.x(), u.y(), u.z());
    }));
 
    cls.def("__eq__", &Vector3d::operator==, py::is_operator());
    cls.def("__ne__", &Vector3d::operator!=, py::is_operator());
    cls.def("__neg__", (Vector3d(Vector3d::*)() const) & Vector3d::operator-);
    cls.def("__add__", &Vector3d::operator+, py::is_operator());
    cls.def("__sub__",
            (Vector3d(Vector3d::*)(Vector3d const &) const) &
                    Vector3d::operator-,
            py::is_operator());
    cls.def("__mul__", &Vector3d::operator*, py::is_operator());
    cls.def("__truediv__", &Vector3d::operator/, py::is_operator());
 
    cls.def("__iadd__", &Vector3d::operator+=);
    cls.def("__isub__", &Vector3d::operator-=);
    cls.def("__imul__", &Vector3d::operator*=);
    cls.def("__itruediv__", &Vector3d::operator/=);
 
    cls.def("x", &Vector3d::x);
    cls.def("y", &Vector3d::y);
    cls.def("z", &Vector3d::z);
    cls.def("dot", &Vector3d::dot);
    cls.def("getSquaredNorm", &Vector3d::getSquaredNorm);
    cls.def("getNorm", &Vector3d::getNorm);
    cls.def("isZero", &Vector3d::isZero);
    cls.def("normalize", &Vector3d::normalize);
    cls.def("isNormalized", &Vector3d::isNormalized);
    cls.def("cross", &Vector3d::cross);
    cls.def("cwiseProduct", &Vector3d::cwiseProduct);
    cls.def("rotatedAround", &Vector3d::rotatedAround, "axis"_a, "angle"_a);
 
    cls.def("__len__", [](Vector3d const &self) { return py::int_(3); });
    cls.def("__getitem__", [](Vector3d const &self, py::int_ i) {
        return self(python::convertIndex(3, i));
    });
 
    cls.def("__str__", [](Vector3d const &self) {
        return py::str("[{!s}, {!s}, {!s}]")
                .format(self.x(), self.y(), self.z());
    });
    cls.def("__repr__", [](Vector3d const &self) {
        return py::str("Vector3d({!r}, {!r}, {!r})")
                .format(self.x(), self.y(), self.z());
    });
 
    cls.def("__reduce__", [cls](Vector3d const &self) {
        return py::make_tuple(cls,
                              py::make_tuple(self.x(), self.y(), self.z()));
    });
}

defineClass() [25/25]

template<typename Pybind11Class>

void lsst::sphgeom::defineClass

(

Pybind11Class &

cls

)

defineCurve()

void lsst::sphgeom::defineCurve

(

py::module &

mod

)

Definition at line 39 of file _curve.cc.

                                {
    mod.def("log2", (uint8_t(*)(uint64_t)) & log2);
    mod.def("mortonIndex", (uint64_t(*)(uint32_t, uint32_t)) & mortonIndex,
            "x"_a, "y"_a);
    mod.def("mortonIndexInverse",
            (std::tuple<uint32_t, uint32_t>(*)(uint64_t)) & mortonIndexInverse,
            "z"_a);
    mod.def("mortonToHilbert", &mortonToHilbert, "z"_a, "m"_a);
    mod.def("hilbertToMorton", &hilbertToMorton, "h"_a, "m"_a);
    mod.def("hilbertIndex",
            (uint64_t(*)(uint32_t, uint32_t, int)) & hilbertIndex, "x"_a, "y"_a,
            "m"_a);
    mod.def("hilbertIndexInverse",
            (std::tuple<uint32_t, uint32_t>(*)(uint64_t, int)) &
                    hilbertIndexInverse,
            "h"_a, "m"_a);
}

defineOrientation()

void lsst::sphgeom::defineOrientation

(

py::module &

mod

)

Definition at line 39 of file _orientation.cc.

                                      {
    mod.def("orientationExact", &orientationExact, "a"_a, "b"_a, "c"_a);
    mod.def("orientation", &orientation, "a"_a, "b"_a, "c"_a);
    mod.def("orientationX", &orientationX, "b"_a, "c"_a);
    mod.def("orientationY", &orientationY, "b"_a, "c"_a);
    mod.def("orientationZ", &orientationZ, "b"_a, "c"_a);
}

defineRelationship()

void lsst::sphgeom::defineRelationship

(

py::module &

mod

)

Definition at line 39 of file _relationship.cc.

                                       {
    mod.attr("DISJOINT") = py::cast(DISJOINT.to_ulong());
    mod.attr("INTERSECTS") = py::cast(INTERSECTS.to_ulong());
    mod.attr("CONTAINS") = py::cast(CONTAINS.to_ulong());
    mod.attr("WITHIN") = py::cast(WITHIN.to_ulong());
 
    mod.def("invert", &invert, "relationship"_a);
}

defineUtils()

void lsst::sphgeom::defineUtils

(

py::module &

mod

)

Definition at line 44 of file _utils.cc.

                                {
    mod.def("getMinSquaredChordLength", &getMinSquaredChordLength, "v"_a, "a"_a,
            "b"_a, "n"_a);
    mod.def("getMaxSquaredChordLength", &getMaxSquaredChordLength, "v"_a, "a"_a,
            "b"_a, "n"_a);
    mod.def("getMinAngleToCircle", &getMinAngleToCircle, "x"_a, "c"_a);
    mod.def("getMaxAngleToCircle", &getMaxAngleToCircle, "x"_a, "c"_a);
    mod.def("getWeightedCentroid", &getWeightedCentroid, "vector0"_a,
            "vector1"_a, "vector2"_a);
}

encodeDouble()

void lsst::sphgeom::encodeDouble ( double item, std::vector< std::uint8_t > & buffer )

inline

encodeDouble appends an IEEE double in little-endian byte order to the end of buffer.

Definition at line 57 of file codec.h.

                                                                      {
#ifdef OPTIMIZED_LITTLE_ENDIAN
    auto ptr = reinterpret_cast<std::uint8_t const *>(&item);
    buffer.insert(buffer.end(), ptr, ptr + 8);
#else
    union { std::uint64_t u; double d; };
    d = item;
    buffer.push_back(static_cast<std::uint8_t>(u));
    buffer.push_back(static_cast<std::uint8_t>(u >> 8));
    buffer.push_back(static_cast<std::uint8_t>(u >> 16));
    buffer.push_back(static_cast<std::uint8_t>(u >> 24));
    buffer.push_back(static_cast<std::uint8_t>(u >> 32));
    buffer.push_back(static_cast<std::uint8_t>(u >> 40));
    buffer.push_back(static_cast<std::uint8_t>(u >> 48));
    buffer.push_back(static_cast<std::uint8_t>(u >> 56));
#endif
}

encodeU64()

void lsst::sphgeom::encodeU64 ( std::uint64_t item, std::vector< std::uint8_t > & buffer )

inline

encodeU64 appends an uint64 in little-endian byte order to the end of buffer.

Definition at line 96 of file codec.h.

                                                                        {
#ifdef OPTIMIZED_LITTLE_ENDIAN
    auto ptr = reinterpret_cast<std::uint8_t const *>(&item);
    buffer.insert(buffer.end(), ptr, ptr + 8);
#else
    union { std::uint64_t u; double d; };
    d = item;
    buffer.push_back(static_cast<std::uint8_t>(u));
    buffer.push_back(static_cast<std::uint8_t>(u >> 8));
    buffer.push_back(static_cast<std::uint8_t>(u >> 16));
    buffer.push_back(static_cast<std::uint8_t>(u >> 24));
    buffer.push_back(static_cast<std::uint8_t>(u >> 32));
    buffer.push_back(static_cast<std::uint8_t>(u >> 40));
    buffer.push_back(static_cast<std::uint8_t>(u >> 48));
    buffer.push_back(static_cast<std::uint8_t>(u >> 56));
#endif
}

getMaxAngleToCircle()

Angle lsst::sphgeom::getMaxAngleToCircle ( Angle x, Angle c )

inline

getMaxAngleToCircle returns the maximum angular separation between a point at latitude x and the points on the circle of constant latitude c.

Definition at line 75 of file utils.h.

                                                   {
    Angle a = getMinAngleToCircle(x, c);
    if (abs(x) <= abs(c)) {
        return a + Angle(PI) - 2.0 * abs(c);
    }
    if (a < abs(x)) {
        return Angle(PI) - 2.0 * abs(c) - a;
    }
    return Angle(PI) + 2.0 * abs(c) - a;
}

getMaxSquaredChordLength()

double lsst::sphgeom::getMaxSquaredChordLength	(	Vector3d const &	v,
		Vector3d const &	a,
		Vector3d const &	b,
		Vector3d const &	n )

Let p be the unit vector furthest from v that lies on the plane with normal n in the direction of the cross product of a and b.

If p is in the interior of the great circle segment from a to b, then this helper function returns the squared chord length between p and v. Otherwise it returns 0 - the minimum squared chord length between any pair of points on the sphere.

Definition at line 65 of file utils.cc.

{
    Vector3d vxn = v.cross(n);
    if (vxn.dot(a) < 0.0 && vxn.dot(b) > 0.0) {
        // v is in the lune defined by the half great circle passing through
        // n and -a and the half great circle passing through n and -b, so p
        // is in the interior of the great circle segment from a to b. The
        // angle θ between p and v satisfies ‖v‖ ‖n‖ sin θ = |v·n|,
        // and ‖v‖ ‖n‖ cos θ = -‖v × n‖. The desired squared chord length is
        // 4 sin²(θ/2).
        double s = std::fabs(v.dot(n));
        double c = - vxn.getNorm();
        double d = std::sin(0.5 * std::atan2(s, c));
        return 4.0 * d * d;
    }
    return 0.0;
}

getMinAngleToCircle()

Angle lsst::sphgeom::getMinAngleToCircle ( Angle x, Angle c )

inline

getMinAngleToCircle returns the minimum angular separation between a point at latitude x and the points on the circle of constant latitude c.

Definition at line 69 of file utils.h.

                                                   {
    return abs(x - c);
}

getMinSquaredChordLength()

double lsst::sphgeom::getMinSquaredChordLength	(	Vector3d const &	v,
		Vector3d const &	a,
		Vector3d const &	b,
		Vector3d const &	n )

Let p be the unit vector closest to v that lies on the plane with normal n in the direction of the cross product of a and b.

If p is in the interior of the great circle segment from a to b, then this function returns the squared chord length between p and v. Otherwise it returns 4 - the maximum squared chord length between any pair of points on the unit sphere.

Definition at line 43 of file utils.cc.

{
    Vector3d vxn = v.cross(n);
    if (vxn.dot(a) > 0.0 && vxn.dot(b) < 0.0) {
        // v is in the lune defined by the half great circle passing through
        // n and a and the half great circle passing through n and b, so p
        // is in the interior of the great circle segment from a to b. The
        // angle θ between p and v satisfies ‖v‖ ‖n‖ sin θ = |v·n|,
        // and ‖v‖ ‖n‖ cos θ = ‖v × n‖. The desired squared chord length is
        // 4 sin²(θ/2).
        double s = std::fabs(v.dot(n));
        double c = vxn.getNorm();
        double theta = (c == 0.0) ? 0.5 * PI : std::atan(s / c);
        double d = std::sin(0.5 * theta);
        return 4.0 * d * d;
    }
    return 4.0;
}

getWeightedCentroid()

Vector3d lsst::sphgeom::getWeightedCentroid	(	UnitVector3d const &	v0,
		UnitVector3d const &	v1,
		UnitVector3d const &	v2 )

getWeightedCentroid returns the center of mass of the given spherical triangle (assuming a uniform mass distribution over the triangle surface), weighted by the triangle area.

Definition at line 86 of file utils.cc.

{
    // For the details, see:
    //
    // The centroid and inertia tensor for a spherical triangle
    // John E. Brock
    // 1974, Naval Postgraduate School, Monterey Calif.
    //
    // https://openlibrary.org/books/OL25493734M/The_centroid_and_inertia_tensor_for_a_spherical_triangle
 
    Vector3d x01 = v0.robustCross(v1); // twice the cross product of v0 and v1
    Vector3d x12 = v1.robustCross(v2);
    Vector3d x20 = v2.robustCross(v0);
    double s01 = 0.5 * x01.normalize(); // sine of the angle between v0 and v1
    double s12 = 0.5 * x12.normalize();
    double s20 = 0.5 * x20.normalize();
    double c01 = v0.dot(v1); // cosine of the angle between v0 and v1
    double c12 = v1.dot(v2);
    double c20 = v2.dot(v0);
    double a0 = (s12 == 0.0 && c12 == 0.0) ? 0.0 : std::atan2(s12, c12);
    double a1 = (s20 == 0.0 && c20 == 0.0) ? 0.0 : std::atan2(s20, c20);
    double a2 = (s01 == 0.0 && c01 == 0.0) ? 0.0 : std::atan2(s01, c01);
    return 0.5 * (x01 * a2 + x12 * a0 + x20 * a1);
}

hilbertIndex()

std::uint64_t lsst::sphgeom::hilbertIndex ( std::uint32_t x, std::uint32_t y, int m )

inline

hilbertIndex returns the index of (x, y) in a 2-D Hilbert curve.

Only the m least significant bits of x and y are used. Computing the Hilbert index of a point has been measured to take 4 to 15 times as long as computing its Morton index on an Intel Core i7-3820QM CPU. With Xcode 7.3 and -O3, latency is ~19ns per call at a CPU frequency of 3.5 GHz.

Definition at line 356 of file curve.h.

                                                                     {
    return mortonToHilbert(mortonIndex(x, y), m);
}

hilbertIndexInverse()

std::tuple< std::uint32_t, std::uint32_t > lsst::sphgeom::hilbertIndexInverse ( std::uint64_t h, int m )

inline

hilbertIndexInverse returns the point (x, y) with Hilbert index h, where x and y are m bit integers.

Definition at line 368 of file curve.h.

                                                                                    {
    return mortonIndexInverse(hilbertToMorton(h, m));
}

hilbertToMorton()

std::uint64_t lsst::sphgeom::hilbertToMorton ( std::uint64_t h, int m )

inline

hilbertToMorton converts the 2m-bit Hilbert index h to the corresponding Morton index.

Definition at line 297 of file curve.h.

                                                         {
    alignas(64) static std::uint8_t const HILBERT_INVERSE_LUT_3[256] = {
        0x40, 0x02, 0x03, 0xc1, 0x04, 0x45, 0x47, 0x86,
        0x0c, 0x4d, 0x4f, 0x8e, 0xcb, 0x89, 0x88, 0x4a,
        0x20, 0x61, 0x63, 0xa2, 0x68, 0x2a, 0x2b, 0xe9,
        0x6c, 0x2e, 0x2f, 0xed, 0xa7, 0xe6, 0xe4, 0x25,
        0x30, 0x71, 0x73, 0xb2, 0x78, 0x3a, 0x3b, 0xf9,
        0x7c, 0x3e, 0x3f, 0xfd, 0xb7, 0xf6, 0xf4, 0x35,
        0xdf, 0x9d, 0x9c, 0x5e, 0x9b, 0xda, 0xd8, 0x19,
        0x93, 0xd2, 0xd0, 0x11, 0x54, 0x16, 0x17, 0xd5,
        0x00, 0x41, 0x43, 0x82, 0x48, 0x0a, 0x0b, 0xc9,
        0x4c, 0x0e, 0x0f, 0xcd, 0x87, 0xc6, 0xc4, 0x05,
        0x50, 0x12, 0x13, 0xd1, 0x14, 0x55, 0x57, 0x96,
        0x1c, 0x5d, 0x5f, 0x9e, 0xdb, 0x99, 0x98, 0x5a,
        0x70, 0x32, 0x33, 0xf1, 0x34, 0x75, 0x77, 0xb6,
        0x3c, 0x7d, 0x7f, 0xbe, 0xfb, 0xb9, 0xb8, 0x7a,
        0xaf, 0xee, 0xec, 0x2d, 0xe7, 0xa5, 0xa4, 0x66,
        0xe3, 0xa1, 0xa0, 0x62, 0x28, 0x69, 0x6b, 0xaa,
        0xff, 0xbd, 0xbc, 0x7e, 0xbb, 0xfa, 0xf8, 0x39,
        0xb3, 0xf2, 0xf0, 0x31, 0x74, 0x36, 0x37, 0xf5,
        0x9f, 0xde, 0xdc, 0x1d, 0xd7, 0x95, 0x94, 0x56,
        0xd3, 0x91, 0x90, 0x52, 0x18, 0x59, 0x5b, 0x9a,
        0x8f, 0xce, 0xcc, 0x0d, 0xc7, 0x85, 0x84, 0x46,
        0xc3, 0x81, 0x80, 0x42, 0x08, 0x49, 0x4b, 0x8a,
        0x60, 0x22, 0x23, 0xe1, 0x24, 0x65, 0x67, 0xa6,
        0x2c, 0x6d, 0x6f, 0xae, 0xeb, 0xa9, 0xa8, 0x6a,
        0xbf, 0xfe, 0xfc, 0x3d, 0xf7, 0xb5, 0xb4, 0x76,
        0xf3, 0xb1, 0xb0, 0x72, 0x38, 0x79, 0x7b, 0xba,
        0xef, 0xad, 0xac, 0x6e, 0xab, 0xea, 0xe8, 0x29,
        0xa3, 0xe2, 0xe0, 0x21, 0x64, 0x26, 0x27, 0xe5,
        0xcf, 0x8d, 0x8c, 0x4e, 0x8b, 0xca, 0xc8, 0x09,
        0x83, 0xc2, 0xc0, 0x01, 0x44, 0x06, 0x07, 0xc5,
        0x10, 0x51, 0x53, 0x92, 0x58, 0x1a, 0x1b, 0xd9,
        0x5c, 0x1e, 0x1f, 0xdd, 0x97, 0xd6, 0xd4, 0x15
    };
    std::uint64_t z = 0;
    std::uint64_t i = 0;
    for (m = 2 * m; m >= 6;) {
        m -= 6;
        std::uint8_t j = HILBERT_INVERSE_LUT_3[i | ((h >> m) & 0x3f)];
        z = (z << 6) | (j & 0x3f);
        i = j & 0xc0;
    }
    if (m != 0) {
        // m = 2 or 4
        int r = 6 - m;
        std::uint8_t j = HILBERT_INVERSE_LUT_3[i | ((h << r) & 0x3f)];
        z = (z << m) | ((j & 0x3f) >> r);
    }
    return z;
}

invert()

Relationship lsst::sphgeom::invert ( Relationship r )

inline

Given the relationship between two sets A and B (i.e.

the output of A.relate(B)), invert returns the relationship between B and A (B.relate(A)).

Definition at line 62 of file Relationship.h.

                                           {
    // If A is disjoint from B, then B is disjoint from A. But if A contains B
    // then B is within A, so the corresponding bits must be swapped.
    return (r & DISJOINT) | ((r & CONTAINS) << 1) | ((r & WITHIN) >> 1);
}

log2() [1/2]

std::uint8_t lsst::sphgeom::log2 ( std::uint32_t x )

inline

log2 returns the index of the most significant 1 bit in x. If x is 0, the return value is 0.

A beautiful algorithm to find this index is presented in:

Using de Bruijn Sequences to Index a 1 in a Computer Word C. E. Leiserson, H. Prokop, and K. H. Randall. http://supertech.csail.mit.edu/papers/debruijn.pdf

Definition at line 132 of file curve.h.

                                      {
    // See https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
    alignas(32) static std::uint8_t const PERFECT_HASH_TABLE[32] = {
        0,  9,  1, 10, 13, 21,  2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
        8, 12, 20, 28, 15, 17, 24,  7, 19, 27, 23,  6, 26,  5, 4, 31
    };
    std::uint32_t const DE_BRUIJN_SEQUENCE = UINT32_C(0x07c4acdd);
    x |= (x >> 1);
    x |= (x >> 2);
    x |= (x >> 4);
    x |= (x >> 8);
    x |= (x >> 16);
    return PERFECT_HASH_TABLE[(DE_BRUIJN_SEQUENCE * x) >> 27];
}

log2() [2/2]

std::uint8_t lsst::sphgeom::log2 ( std::uint64_t x )

inline

log2 returns the index of the most significant 1 bit in x. If x is 0, the return value is 0.

A beautiful algorithm to find this index is presented in:

Using de Bruijn Sequences to Index a 1 in a Computer Word C. E. Leiserson, H. Prokop, and K. H. Randall. http://supertech.csail.mit.edu/papers/debruijn.pdf

Definition at line 105 of file curve.h.

                                      {
    alignas(64) static std::uint8_t const PERFECT_HASH_TABLE[64] = {
         0,  1,  2,  7,  3, 13,  8, 19,  4, 25, 14, 28,  9, 34, 20, 40,
         5, 17, 26, 38, 15, 46, 29, 48, 10, 31, 35, 54, 21, 50, 41, 57,
        63,  6, 12, 18, 24, 27, 33, 39, 16, 37, 45, 47, 30, 53, 49, 56,
        62, 11, 23, 32, 36, 44, 52, 55, 61, 22, 43, 51, 60, 42, 59, 58
    };
    std::uint64_t const DE_BRUIJN_SEQUENCE = UINT64_C(0x0218a392cd3d5dbf);
    // First ensure that all bits below the MSB are set.
    x |= (x >> 1);
    x |= (x >> 2);
    x |= (x >> 4);
    x |= (x >> 8);
    x |= (x >> 16);
    x |= (x >> 32);
    // Then, subtract them away.
    x = x - (x >> 1);
    // Multiplication by x is now a shift by the index i of the MSB.
    //
    // By definition, the value of the upper 6 bits of a 64-bit De Bruijn
    // sequence left shifted by i is different for every value of i in
    // [0, 64). It can therefore be used as an an index into a lookup table
    // that recovers i. In other words, (DE_BRUIJN_SEQUENCE * x) >> 58 is a
    // minimal perfect hash function for 64 bit powers of 2.
    return PERFECT_HASH_TABLE[(DE_BRUIJN_SEQUENCE * x) >> 58];
}

mortonIndex()

std::uint64_t lsst::sphgeom::mortonIndex ( std::uint32_t x, std::uint32_t y )

inline

mortonIndex interleaves the bits of x and y.

The 32 even bits of the return value will be the bits of x, and the 32 odd bits those of y. This is the z-value of (x,y) defined by the Morton order function. See https://en.wikipedia.org/wiki/Z-order_curve for more information.

Definition at line 155 of file curve.h.

                                                                 {
        // This is just a 64-bit extension of:
        // http://graphics.stanford.edu/~seander/bithacks.html#InterleaveBMN
        std::uint64_t b = y;
        std::uint64_t a = x;
        b = (b | (b << 16)) & UINT64_C(0x0000ffff0000ffff);
        a = (a | (a << 16)) & UINT64_C(0x0000ffff0000ffff);
        b = (b | (b << 8)) & UINT64_C(0x00ff00ff00ff00ff);
        a = (a | (a << 8)) & UINT64_C(0x00ff00ff00ff00ff);
        b = (b | (b << 4)) & UINT64_C(0x0f0f0f0f0f0f0f0f);
        a = (a | (a << 4)) & UINT64_C(0x0f0f0f0f0f0f0f0f);
        b = (b | (b << 2)) & UINT64_C(0x3333333333333333);
        a = (a | (a << 2)) & UINT64_C(0x3333333333333333);
        b = (b | (b << 1)) & UINT64_C(0x5555555555555555);
        a = (a | (a << 1)) & UINT64_C(0x5555555555555555);
        return a | (b << 1);
    }

mortonIndexInverse()

std::tuple< std::uint32_t, std::uint32_t > lsst::sphgeom::mortonIndexInverse ( std::uint64_t z )

inline

mortonIndexInverse separates the even and odd bits of z.

The 32 even bits of z are returned in the first element of the result tuple, and the 32 odd bits in the second. This is the inverse of mortonIndex().

Definition at line 202 of file curve.h.

                                                                                {
        std::uint64_t x = z & UINT64_C(0x5555555555555555);
        std::uint64_t y = (z >> 1) & UINT64_C(0x5555555555555555);
        x = (x | (x >> 1)) & UINT64_C(0x3333333333333333);
        y = (y | (y >> 1)) & UINT64_C(0x3333333333333333);
        x = (x | (x >> 2)) & UINT64_C(0x0f0f0f0f0f0f0f0f);
        y = (y | (y >> 2)) & UINT64_C(0x0f0f0f0f0f0f0f0f);
        x = (x | (x >> 4)) & UINT64_C(0x00ff00ff00ff00ff);
        y = (y | (y >> 4)) & UINT64_C(0x00ff00ff00ff00ff);
        x = (x | (x >> 8)) & UINT64_C(0x0000ffff0000ffff);
        y = (y | (y >> 8)) & UINT64_C(0x0000ffff0000ffff);
        return std::make_tuple(static_cast<std::uint32_t>(x | (x >> 16)),
                               static_cast<std::uint32_t>(y | (y >> 16)));
    }

mortonToHilbert()

std::uint64_t lsst::sphgeom::mortonToHilbert ( std::uint64_t z, int m )

inline

mortonToHilbert converts the 2m-bit Morton index z to the corresponding Hilbert index.

Definition at line 243 of file curve.h.

                                                         {
    alignas(64) static std::uint8_t const HILBERT_LUT_3[256] = {
        0x40, 0xc3, 0x01, 0x02, 0x04, 0x45, 0x87, 0x46,
        0x8e, 0x8d, 0x4f, 0xcc, 0x08, 0x49, 0x8b, 0x4a,
        0xfa, 0x3b, 0xf9, 0xb8, 0x7c, 0xff, 0x3d, 0x3e,
        0xf6, 0x37, 0xf5, 0xb4, 0xb2, 0xb1, 0x73, 0xf0,
        0x10, 0x51, 0x93, 0x52, 0xde, 0x1f, 0xdd, 0x9c,
        0x54, 0xd7, 0x15, 0x16, 0x58, 0xdb, 0x19, 0x1a,
        0x20, 0x61, 0xa3, 0x62, 0xee, 0x2f, 0xed, 0xac,
        0x64, 0xe7, 0x25, 0x26, 0x68, 0xeb, 0x29, 0x2a,
        0x00, 0x41, 0x83, 0x42, 0xce, 0x0f, 0xcd, 0x8c,
        0x44, 0xc7, 0x05, 0x06, 0x48, 0xcb, 0x09, 0x0a,
        0x50, 0xd3, 0x11, 0x12, 0x14, 0x55, 0x97, 0x56,
        0x9e, 0x9d, 0x5f, 0xdc, 0x18, 0x59, 0x9b, 0x5a,
        0xba, 0xb9, 0x7b, 0xf8, 0xb6, 0xb5, 0x77, 0xf4,
        0x3c, 0x7d, 0xbf, 0x7e, 0xf2, 0x33, 0xf1, 0xb0,
        0x60, 0xe3, 0x21, 0x22, 0x24, 0x65, 0xa7, 0x66,
        0xae, 0xad, 0x6f, 0xec, 0x28, 0x69, 0xab, 0x6a,
        0xaa, 0xa9, 0x6b, 0xe8, 0xa6, 0xa5, 0x67, 0xe4,
        0x2c, 0x6d, 0xaf, 0x6e, 0xe2, 0x23, 0xe1, 0xa0,
        0x9a, 0x99, 0x5b, 0xd8, 0x96, 0x95, 0x57, 0xd4,
        0x1c, 0x5d, 0x9f, 0x5e, 0xd2, 0x13, 0xd1, 0x90,
        0x70, 0xf3, 0x31, 0x32, 0x34, 0x75, 0xb7, 0x76,
        0xbe, 0xbd, 0x7f, 0xfc, 0x38, 0x79, 0xbb, 0x7a,
        0xca, 0x0b, 0xc9, 0x88, 0x4c, 0xcf, 0x0d, 0x0e,
        0xc6, 0x07, 0xc5, 0x84, 0x82, 0x81, 0x43, 0xc0,
        0xea, 0x2b, 0xe9, 0xa8, 0x6c, 0xef, 0x2d, 0x2e,
        0xe6, 0x27, 0xe5, 0xa4, 0xa2, 0xa1, 0x63, 0xe0,
        0x30, 0x71, 0xb3, 0x72, 0xfe, 0x3f, 0xfd, 0xbc,
        0x74, 0xf7, 0x35, 0x36, 0x78, 0xfb, 0x39, 0x3a,
        0xda, 0x1b, 0xd9, 0x98, 0x5c, 0xdf, 0x1d, 0x1e,
        0xd6, 0x17, 0xd5, 0x94, 0x92, 0x91, 0x53, 0xd0,
        0x8a, 0x89, 0x4b, 0xc8, 0x86, 0x85, 0x47, 0xc4,
        0x0c, 0x4d, 0x8f, 0x4e, 0xc2, 0x03, 0xc1, 0x80
    };
    std::uint64_t h = 0;
    std::uint64_t i = 0;
    for (m = 2 * m; m >= 6;) {
        m -= 6;
        std::uint8_t j = HILBERT_LUT_3[i | ((z >> m) & 0x3f)];
        h = (h << 6) | (j & 0x3f);
        i = j & 0xc0;
    }
    if (m != 0) {
        // m = 2 or 4
        int r = 6 - m;
        std::uint8_t j = HILBERT_LUT_3[i | ((z << r) & 0x3f)];
        h = (h << m) | ((j & 0x3f) >> r);
    }
    return h;
}

operator*() [1/2]

Angle lsst::sphgeom::operator* ( double a, Angle const & b )

inline

Definition at line 105 of file Angle.h.

{ return b * a; }

operator*() [2/2]

Vector3d lsst::sphgeom::operator* ( double s, Vector3d const & v )

inline

Definition at line 172 of file Vector3d.h.

{ return v * s; }

operator<<() [1/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Angle const &	a )

Definition at line 41 of file Angle.cc.

                                                          {
    char buf[32];
    std::snprintf(buf, sizeof(buf), "%.17g", a.asRadians());
    return os << buf;
}

operator<<() [2/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		AngleInterval const &	i )

Definition at line 41 of file AngleInterval.cc.

                                                                  {
    return os << '[' << i.getA() << ", " << i.getB() << ']';
}

operator<<() [3/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Box const &	b )

Definition at line 502 of file Box.cc.

                                                        {
    return os << "{\"Box\": [" << b.getLon() << ", " << b.getLat() << "]}";
}

operator<<() [4/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Box3d const &	b )

Definition at line 41 of file Box3d.cc.

                                                          {
    return os << "{\"Box3d\": [" << b.x() << ", " << b.y() << ", " << b.z() << "]}";
}

operator<<() [5/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Circle const &	c )

Definition at line 388 of file Circle.cc.

                                                           {
    char tail[32];
    std::snprintf(tail, sizeof(tail), ", %.17g]}", c.getSquaredChordLength());
    return os << "{\"Circle\": [" << c.getCenter() << tail;
}

operator<<() [6/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		ConvexPolygon const &	p )

Definition at line 414 of file ConvexPolygon.cc.

                                                                  {
    typedef std::vector<UnitVector3d>::const_iterator VertexIterator;
    VertexIterator v = p.getVertices().begin();
    VertexIterator const end = p.getVertices().end();
    os << "{\"ConvexPolygon\": [" << *v;
    for (++v; v != end; ++v) { os << ", " << *v; }
    os << "]}";
    return os;
}

operator<<() [7/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Ellipse const &	e )

Definition at line 419 of file Ellipse.cc.

                                                            {
    os << "{\"Ellipse\": [" << e.getTransformMatrix() << ", "
       << e.getAlpha() << ", " << e.getBeta() << "]}";
    return os;
}

operator<<() [8/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Interval1d const &	i )

Definition at line 42 of file Interval1d.cc.

                                                               {
    char buf[64];
    std::snprintf(buf, sizeof(buf), "[%.17g, %.17g]", i.getA(), i.getB());
    return os << buf;
}

operator<<() [9/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		LonLat const &	p )

Definition at line 89 of file LonLat.cc.

                                                           {
    return os << '[' << p.getLon() << ", " << p.getLat() << ']';
}

operator<<() [10/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Matrix3d const &	m )

Definition at line 42 of file Matrix3d.cc.

                                                             {
    return os << '[' << m.getRow(0) << ", " << m.getRow(1) << ", " << m.getRow(2) << ']';
}

operator<<() [11/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		NormalizedAngleInterval const &	i )

Definition at line 291 of file NormalizedAngleInterval.cc.

{
    return os << '[' << i.getA() << ", " << i.getB() << ']';
}

operator<<() [12/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		RangeSet const &	s )

Definition at line 623 of file RangeSet.cc.

                                                             {
    os << "{\"RangeSet\": [";
    bool first = true;
    for (auto const & t: s) {
        if (!first) {
            os << ", ";
        }
        first = false;
        os << '[' << std::get<0>(t) << ", " << std::get<1>(t) << ']';
    }
    os << "]}";
    return os;
}

operator<<() [13/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		UnitVector3d const &	v )

Definition at line 80 of file UnitVector3d.cc.

                                                                 {
    return os << static_cast<Vector3d const &>(v);
}

operator<<() [14/15]

std::ostream & lsst::sphgeom::operator<<	(	std::ostream &	os,
		Vector3d const &	v )

Definition at line 141 of file Vector3d.cc.

                                                             {
    char buf[128];
    std::snprintf(buf, sizeof(buf), "[%.17g, %.17g, %.17g]",
                  v.x(), v.y(), v.z());
    return os << buf;
}

operator<<() [15/15]

std::ostream & lsst::sphgeom::operator<< ( std::ostream & stream, TriState const & value )

inline

Definition at line 131 of file TriState.h.

                                                                     {
    const char* str = "unknown";
    if (value == true) {
        str = "true";
    } else if (value == false) {
        str = "false";
    }
    return stream << str;
}

orientation()

int lsst::sphgeom::orientation	(	UnitVector3d const &	a,
		UnitVector3d const &	b,
		UnitVector3d const &	c )

orientation computes and returns the orientations of 3 unit vectors a, b and c.

The return value is +1 if the vectors are in counter-clockwise orientation, 0 if they are coplanar, colinear or identical, and -1 if they are in clockwise orientation.

This is equivalent to computing the sign of the scalar triple product a · (b x c), which is the sign of the determinant of the 3x3 matrix with a, b and c as columns/rows.

The implementation proceeds by first computing a double precision approximation, and then falling back to arbitrary precision arithmetic when necessary. Consequently, the result is exact.

Definition at line 142 of file orientation.cc.

{
    // This constant is a little more than 5ε, where ε = 2^-53. When multiplied
    // by the permanent of |M|, it gives an error bound on the determinant of
    // M. Here, M is a 3x3 matrix and |M| denotes the matrix obtained by
    // taking the absolute value of each of its components. The derivation of
    // this proceeds in the same manner as the derivation of the error bounds
    // in section 4.3 of:
    //
    //     Adaptive Precision Floating-Point Arithmetic
    //     and Fast Robust Geometric Predicates,
    //     Jonathan Richard Shewchuk,
    //     Discrete & Computational Geometry 18(3):305–363, October 1997.
    //
    // available online at http://www.cs.berkeley.edu/~jrs/papers/robustr.pdf
    static double const relativeError = 5.6e-16;
    // Because all 3 unit vectors are normalized, the maximum absolute value of
    // any vector component, cross product component or dot product term in
    // the calculation is very close to 1. The permanent of |M| must therefore
    // be below 3 + c, where c is some small multiple of ε. This constant, a
    // little larger than 3 * 5ε, is an upper bound on the absolute error in
    // the determinant calculation.
    static double const maxAbsoluteError = 1.7e-15;
    // This constant accounts for floating point underflow (assuming hardware
    // without gradual underflow, just to be conservative) in the computation
    // of det(M). It is a little more than 14 * 2^-1022.
    static double const minAbsoluteError = 4.0e-307;
 
    double bycz = b.y() * c.z();
    double bzcy = b.z() * c.y();
    double bzcx = b.z() * c.x();
    double bxcz = b.x() * c.z();
    double bxcy = b.x() * c.y();
    double bycx = b.y() * c.x();
    double determinant = a.x() * (bycz - bzcy) +
                         a.y() * (bzcx - bxcz) +
                         a.z() * (bxcy - bycx);
    if (determinant > maxAbsoluteError) {
        return 1;
    } else if (determinant < -maxAbsoluteError) {
        return -1;
    }
    // Expend some more effort on what is hopefully a tighter error bound
    // before falling back on arbitrary precision arithmetic.
    double permanent = std::fabs(a.x()) * (std::fabs(bycz) + std::fabs(bzcy)) +
                       std::fabs(a.y()) * (std::fabs(bzcx) + std::fabs(bxcz)) +
                       std::fabs(a.z()) * (std::fabs(bxcy) + std::fabs(bycx));
    double maxError = relativeError * permanent + minAbsoluteError;
    if (determinant > maxError) {
        return 1;
    } else if (determinant < -maxError) {
        return -1;
    }
    // Avoid the slow path when any two inputs are identical or antipodal.
    if (a == b || b == c || a == c || a == -b || b == -c || a == -c) {
        return 0;
    }
    return orientationExact(a, b, c);
}

orientationExact()

int lsst::sphgeom::orientationExact	(	Vector3d const &	a,
		Vector3d const &	b,
		Vector3d const &	c )

orientationExact computes and returns the orientations of 3 vectors a, b and c, which need not be normalized but are assumed to have finite components.

The return value is +1 if the vectors a, b, and c are in counter-clockwise orientation, 0 if they are coplanar, colinear, or identical, and -1 if they are in clockwise orientation. The implementation uses arbitrary precision arithmetic to avoid floating point rounding error, underflow and overflow.

Definition at line 83 of file orientation.cc.

{
    // Product mantissa storage buffers.
    std::uint32_t mantissaBuffers[6][6];
    // Product mantissas.
    BigInteger mantissas[6] = {
        BigInteger(mantissaBuffers[0], 6),
        BigInteger(mantissaBuffers[1], 6),
        BigInteger(mantissaBuffers[2], 6),
        BigInteger(mantissaBuffers[3], 6),
        BigInteger(mantissaBuffers[4], 6),
        BigInteger(mantissaBuffers[5], 6)
    };
    BigFloat products[6] = {
        BigFloat(&mantissas[0]),
        BigFloat(&mantissas[1]),
        BigFloat(&mantissas[2]),
        BigFloat(&mantissas[3]),
        BigFloat(&mantissas[4]),
        BigFloat(&mantissas[5])
    };
    // An accumulator and its storage.
    std::uint32_t accumulatorBuffer[512];
    BigInteger accumulator(accumulatorBuffer,
                           sizeof(accumulatorBuffer) / sizeof(std::uint32_t));
    // Compute the products in the determinant. Performing all multiplication
    // up front means that each product mantissa occupies at most 3*53 bits.
    computeProduct(products[0], a.x(), b.y(), c.z());
    computeProduct(products[1], a.x(), b.z(), c.y());
    computeProduct(products[2], a.y(), b.z(), c.x());
    computeProduct(products[3], a.y(), b.x(), c.z());
    computeProduct(products[4], a.z(), b.x(), c.y());
    computeProduct(products[5], a.z(), b.y(), c.x());
    mantissas[1].negate();
    mantissas[3].negate();
    mantissas[5].negate();
    // Sort the array of products in descending exponent order.
    std::sort(products, products + 6, [](BigFloat const & a, BigFloat const & b) {
        return a.exponent > b.exponent;
    });
    // First, initialize the accumulator to the product with the highest
    // exponent, then add the remaining products. Prior to each addition, we
    // must shift the accumulated value so that its radix point lines up with
    // the the radix point of the product to add.
    //
    // More precisely, at each step we have an accumulated value A·2ʲ and a
    // product P·2ᵏ, and we update the accumulator to equal (A·2ʲ⁻ᵏ + P)·2ᵏ.
    // Because the products were sorted beforehand, j ≥ k and 2ʲ⁻ᵏ is an
    // integer.
    accumulator = *products[0].mantissa;
    for (int i = 1; i < 6; ++i) {
        accumulator.multiplyPow2(products[i - 1].exponent - products[i].exponent);
        accumulator.add(*products[i].mantissa);
    }
    return accumulator.getSign();
}

orientationX()

int lsst::sphgeom::orientationX	(	UnitVector3d const &	b,
		UnitVector3d const &	c )

orientationX(b, c) is equivalent to orientation(UnitVector3d::X(), b, c).

Definition at line 234 of file orientation.cc.

                                                                 {
    int o = _orientationXYZ(b.y() * c.z(), b.z() * c.y());
    return (o != 0) ? o : orientationExact(UnitVector3d::X(), b, c);
}

orientationY()

int lsst::sphgeom::orientationY	(	UnitVector3d const &	b,
		UnitVector3d const &	c )

orientationY(b, c) is equivalent to orientation(UnitVector3d::Y(), b, c).

Definition at line 239 of file orientation.cc.

                                                                 {
    int o = _orientationXYZ(b.z() * c.x(), b.x() * c.z());
    return (o != 0) ? o : orientationExact(UnitVector3d::Y(), b, c);
}

orientationZ()

int lsst::sphgeom::orientationZ	(	UnitVector3d const &	b,
		UnitVector3d const &	c )

orientationZ(b, c) is equivalent to orientation(UnitVector3d::Z(), b, c).

Definition at line 244 of file orientation.cc.

                                                                 {
    int o = _orientationXYZ(b.x() * c.y(), b.y() * c.x());
    return (o != 0) ? o : orientationExact(UnitVector3d::Z(), b, c);
}

sin()

double lsst::sphgeom::sin ( Angle const & a )

inline

Definition at line 109 of file Angle.h.

{ return std::sin(a.asRadians()); }

swap()

void lsst::sphgeom::swap ( RangeSet & a, RangeSet & b )

inline

Definition at line 615 of file RangeSet.h.

                                             {
    a.swap(b);
}

tan()

double lsst::sphgeom::tan ( Angle const & a )

inline

Definition at line 111 of file Angle.h.

{ return std::tan(a.asRadians()); }

Variable Documentation

DEG_PER_RAD

double lsst::sphgeom::DEG_PER_RAD = 57.2957795130823208767981548141

constexpr

Definition at line 46 of file constants.h.

EPSILON

double lsst::sphgeom::EPSILON = 1.1102230246251565e-16

constexpr

Definition at line 61 of file constants.h.

MAX_ASIN_ERROR

double lsst::sphgeom::MAX_ASIN_ERROR = 1.5e-8

constexpr

Definition at line 52 of file constants.h.

MAX_SQUARED_CHORD_LENGTH_ERROR

double lsst::sphgeom::MAX_SQUARED_CHORD_LENGTH_ERROR = 2.5e-15

constexpr

Definition at line 57 of file constants.h.

ONE_OVER_PI

double lsst::sphgeom::ONE_OVER_PI = 0.318309886183790671537767526745

constexpr

Definition at line 44 of file constants.h.

PI

double lsst::sphgeom::PI = 3.1415926535897932384626433832795

constexpr

Definition at line 43 of file constants.h.

RAD_PER_DEG

double lsst::sphgeom::RAD_PER_DEG = 0.0174532925199432957692369076849

constexpr

Definition at line 45 of file constants.h.