lsst::sphgeom::Q3cPixelization Class Reference

Q3cPixelization provides Q3C indexing of points and regions. More...

#include <Q3cPixelization.h>

Inheritance diagram for lsst::sphgeom::Q3cPixelization:

Public Member Functions
	Q3cPixelization (int level)
	This constructor creates a Q3C pixelization of the sphere with the given subdivision level.
int	getLevel () const
	getLevel returns the subdivision level of this pixelization.
ConvexPolygon	quad (uint64_t i) const
	quad returns the quadrilateral corresponding to the Q3C pixel with index i.
std::vector< uint64_t >	neighborhood (uint64_t i) const
	neighborhood returns the indexes of all pixels that share a vertex with pixel i (including i itself).
RangeSet	universe () const override
	universe returns the set of all pixel indexes for this pixelization.
std::unique_ptr< Region >	pixel (uint64_t i) const override
	pixel returns the spherical region corresponding to the pixel with index i.
uint64_t	index (UnitVector3d const &v) const override
	index computes the index of the pixel for v.
std::string	toString (uint64_t i) const override
	toString converts the given Q3C index to a human readable string.
RangeSet	envelope (Region const &r, size_t maxRanges=0) const
	envelope returns the indexes of the pixels intersecting the spherical region r.
RangeSet	interior (Region const &r, size_t maxRanges=0) const
	interior returns the indexes of the pixels within the spherical region r.

Static Public Attributes
static constexpr int	MAX_LEVEL = 30
	The maximum supported cube-face grid resolution is 2^30 by 2^30.

Private Member Functions
RangeSet	_envelope (Region const &r, size_t maxRanges) const override
RangeSet	_interior (Region const &r, size_t maxRanges) const override

Detailed Description

Q3cPixelization provides Q3C indexing of points and regions.

Instances of this class are immutable and very cheap to copy.

Warning

Setting the maxRanges argument for envelope() or interior() to a non-zero value below 4 can result in very poor region pixelizations regardless of region size. For instance, if maxRanges is 1, a non-empty circle centered on an axis will be approximated by the indexes for an entire cube face, even as the circle radius tends to 0.

Definition at line 57 of file Q3cPixelization.h.

Constructor & Destructor Documentation

Q3cPixelization()

lsst::sphgeom::Q3cPixelization::Q3cPixelization ( int level )

explicit

This constructor creates a Q3C pixelization of the sphere with the given subdivision level.

If level ∉ [0, MAX_LEVEL], a std::invalid_argument is thrown.

Definition at line 263 of file Q3cPixelization.cc.

                                          : _level{level} {
    if (level < 0 || level > MAX_LEVEL) {
        throw std::invalid_argument("Q3C subdivision level not in [0, 30]");
    }
}

Member Function Documentation

_envelope()

RangeSet lsst::sphgeom::Q3cPixelization::_envelope ( Region const & r, size_t maxRanges ) const

overrideprivatevirtual

Implements lsst::sphgeom::Pixelization.

Definition at line 343 of file Q3cPixelization.cc.

                                                                            {
    return detail::findPixels<Q3cPixelFinder, false>(r, maxRanges, _level);
}

_interior()

RangeSet lsst::sphgeom::Q3cPixelization::_interior ( Region const & r, size_t maxRanges ) const

overrideprivatevirtual

Implements lsst::sphgeom::Pixelization.

Definition at line 347 of file Q3cPixelization.cc.

                                                                            {
    return detail::findPixels<Q3cPixelFinder, true>(r, maxRanges, _level);
}

envelope()

RangeSet lsst::sphgeom::Pixelization::envelope ( Region const & r, size_t maxRanges = 0 ) const

inlineinherited

envelope returns the indexes of the pixels intersecting the spherical region r.

For hierarchical pixelizations, a good way to implement this is by top down tree traversal. Starting with the root pixels (e.g. Q3C cube faces, or HTM root triangles), a pixel P is tested for intersection with the region r. If P is already at the desired subdivision level and intersects r, its index is added to the output. If r contains P, the indexes of all children of P at the target subdivision level are output. Finally, if P intersects r, then P is subdivided and the algorithm recurses on its child pixels.

Using higher subdivision levels allows a region to be more closely approximated by smaller pixels, but for large input regions the cost of computing and storing their indexes can quickly become prohibitive.

The maxRanges parameter can be used to limit both these costs - setting it to a non-zero value sets a cap on the number of ranges returned by this method. To meet this constraint, implementations are allowed to return pixels that do not intersect r along with those that do. This allows two ranges [a, b) and [c, d), a < b < c < d, to be merged into one range [a, d) (by adding in the pixels [b, c)). Since simplification proceeds by adding pixels, the return value will always be a superset of the intersecting pixels.

In practice, the implementation of this method for a hierarchical pixelization like Q3C or HTM will lower the subdivision level when too many ranges have been found. Each coarse pixel I at level L - n corresponds to pixels [I*4ⁿ, (I + 1)*4ⁿ) at level L.

Definition at line 138 of file Pixelization.h.

                                                                    {
        return _envelope(r, maxRanges);
    }

getLevel()

int lsst::sphgeom::Q3cPixelization::getLevel ( ) const

inline

getLevel returns the subdivision level of this pixelization.

Definition at line 68 of file Q3cPixelization.h.

{ return _level; }

index()

uint64_t lsst::sphgeom::Q3cPixelization::index ( UnitVector3d const & v ) const

overridevirtual

index computes the index of the pixel for v.

Implements lsst::sphgeom::Pixelization.

Definition at line 319 of file Q3cPixelization.cc.

                                                                {
        int face = faceNumber(p, FACE_NUM);
        double w = std::fabs(p(FACE_COMP[face][2]));
        double u = (p(FACE_COMP[face][0]) / w) * FACE_CONST[face][0];
        double v = (p(FACE_COMP[face][1]) / w) * FACE_CONST[face][1];
        std::tuple<int32_t, int32_t> g = faceToGrid(_level, u, v);
        uint64_t z = mortonIndex(static_cast<uint32_t>(std::get<0>(g)),
                                 static_cast<uint32_t>(std::get<1>(g)));
        return (static_cast<uint64_t>(face) << (2 * _level)) | z;
    }

interior()

RangeSet lsst::sphgeom::Pixelization::interior ( Region const & r, size_t maxRanges = 0 ) const

inlineinherited

interior returns the indexes of the pixels within the spherical region r.

The maxRanges argument is analogous to the identically named envelope() argument. The only difference is that implementations must remove interior pixels to keep the number of ranges at or below the maximum. The return value is therefore always a subset of the interior pixels.

Definition at line 150 of file Pixelization.h.

                                                                    {
        return _interior(r, maxRanges);
    }

neighborhood()

std::vector< uint64_t > lsst::sphgeom::Q3cPixelization::neighborhood

(

uint64_t

i

)

const

neighborhood returns the indexes of all pixels that share a vertex with pixel i (including i itself).

A Q3C pixel has 8 - k adjacent pixels, where k is the number of vertices that are also root pixel vertices (0, 1, or 4).

If i is not a valid Q3C index, a std::invalid_argument is thrown.

Definition at line 278 of file Q3cPixelization.cc.

                                                                  {
    if (i >= static_cast<uint64_t>(6) << (2 * _level)) {
        throw std::invalid_argument("Invalid Q3C index");
    }
    uint64_t indexes[9];
    int n = findNeighborhood(_level, i, indexes);
    return std::vector<uint64_t>(indexes, indexes + n);
}

pixel()

std::unique_ptr< Region > lsst::sphgeom::Q3cPixelization::pixel ( uint64_t i ) const

overridevirtual

pixel returns the spherical region corresponding to the pixel with index i.

This region will contain all unit vectors v with index(v) == i. But it may also contain points with index not equal to i. To see why, consider a point that lies on the edge of a polygonal pixel - it is inside the polygons for both pixels sharing the edge, but must be assigned to exactly one pixel by the pixelization.

If i is not a valid pixel index, a std::invalid_argument is thrown.

Implements lsst::sphgeom::Pixelization.

Definition at line 308 of file Q3cPixelization.cc.

                                                             {
    if (i >= static_cast<uint64_t>(6) << (2 * _level)) {
        throw std::invalid_argument("Invalid Q3C index");
    }
    UnitVector3d verts[4];
    makeQuad(i, _level, verts);
    return std::unique_ptr<Region>(
        new ConvexPolygon(verts[0], verts[1], verts[2], verts[3]));
}

quad()

ConvexPolygon lsst::sphgeom::Q3cPixelization::quad

(

uint64_t

i

)

const

quad returns the quadrilateral corresponding to the Q3C pixel with index i.

If i is not a valid Q3C index, a std::invalid_argument is thrown.

Definition at line 269 of file Q3cPixelization.cc.

                                                    {
    if (i >= static_cast<uint64_t>(6) << (2 * _level)) {
        throw std::invalid_argument("Invalid Q3C index");
    }
    UnitVector3d verts[4];
    makeQuad(i, _level, verts);
    return ConvexPolygon(verts[0], verts[1], verts[2], verts[3]);
}

toString()

std::string lsst::sphgeom::Q3cPixelization::toString ( uint64_t i ) const

overridevirtual

toString converts the given Q3C index to a human readable string.

The first two characters in the return value are always '+X', '+Y', '+Z', '-X', '-Y', or '-Z'. They give the normal vector of the cube face F containing i. Each subsequent character is a digit in [0-3] corresponding to a child pixel index, so that reading the string from left to right corresponds to descent of the quad-tree overlaid on F.

If i is not a valid Q3C index, a std::invalid_argument is thrown.

Implements lsst::sphgeom::Pixelization.

Definition at line 287 of file Q3cPixelization.cc.

                                                    {
    static char const FACE_NORM[6][2] = {
        {'+', 'Z'}, {'+', 'X'}, {'+', 'Y'},
        {'-', 'X'}, {'-', 'Y'}, {'-', 'Z'},
    };
    char s[MAX_LEVEL + 2];
    if (i >= static_cast<uint64_t>(6) << (2 * _level)) {
        throw std::invalid_argument("Invalid Q3C index");
    }
    // Print in base-4, from least to most significant digit.
    char * p = s + (sizeof(s) - 1);
    for (int l = _level; l > 0; --l, --p, i >>= 2) {
        *p = '0' + (i & 3);
    }
    // The remaining bits correspond to the cube face.
    --p;
    p[0] = FACE_NORM[i][0];
    p[1] = FACE_NORM[i][1];
    return std::string(p, sizeof(s) - static_cast<size_t>(p - s));
}

universe()

RangeSet lsst::sphgeom::Q3cPixelization::universe ( ) const

inlineoverridevirtual

universe returns the set of all pixel indexes for this pixelization.

Implements lsst::sphgeom::Pixelization.

Definition at line 84 of file Q3cPixelization.h.

                                       {
        return RangeSet(0, static_cast<uint64_t>(6) << 2 * _level);
    }

Member Data Documentation

MAX_LEVEL

constexpr int lsst::sphgeom::Q3cPixelization::MAX_LEVEL = 30

staticconstexpr

The maximum supported cube-face grid resolution is 2^30 by 2^30.

Definition at line 60 of file Q3cPixelization.h.

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/sphgeom/g8a8a8dda67+a6fc98d2e7/include/lsst/sphgeom/Q3cPixelization.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/sphgeom/g8a8a8dda67+a6fc98d2e7/src/Q3cPixelization.cc