lsst::sphgeom::Chunker Class Reference

Chunker subdivides the unit sphere into longitude-latitude boxes. More...

#include <Chunker.h>

Public Member Functions
	Chunker (int32_t numStripes, int32_t numSubStripesPerStripe)
bool	operator== (Chunker const &c) const
bool	operator!= (Chunker const &c) const
int32_t	getNumStripes () const
	getNumStripes returns the number of fixed-height latitude intervals in the sky subdivision. More...
int32_t	getNumSubStripesPerStripe () const
	getNumSubStripesPerStripe returns the number of fixed-height latitude sub-intervals in each stripe. More...
std::vector< int32_t >	getChunksIntersecting (Region const &r) const
	getChunksIntersecting returns all the chunks that potentially intersect the given region. More...
std::vector< SubChunks >	getSubChunksIntersecting (Region const &r) const
	getSubChunksIntersecting returns all the sub-chunks that potentially intersect the given region. More...
std::vector< int32_t >	getAllChunks () const
	getAllChunks returns the complete set of chunk IDs for the unit sphere. More...
std::vector< int32_t >	getAllSubChunks (int32_t chunkId) const
	getAllSubChunks returns the complete set of sub-chunk IDs for the given chunk. More...
bool	valid (int32_t chunkId) const
	Return 'true' if the specified chunk number is valid. More...
Box	getChunkBoundingBox (int32_t stripe, int32_t chunk) const
Box	getSubChunkBoundingBox (int32_t subStripe, int32_t subChunk) const
int32_t	getStripe (int32_t chunkId) const
	Return the stripe for the specified chunkId. More...
int32_t	getChunk (int32_t chunkId, int32_t stripe) const
	Return the chunk for the given chunkId and stripe. More...

Detailed Description

Chunker subdivides the unit sphere into longitude-latitude boxes.

The unit sphere is divided into latitude angle "stripes" of fixed height H. For each stripe, a width W is computed such that any two points in the stripe with longitude angles separated by at least W have angular separation of at least H. The stripe is then broken into an integral number of chunks of width at least W. The same procedure is used to obtain finer subchunks - each stripe is broken into a configureable number of equal-height "substripes", and each substripe is broken into equal-width subchunks.

Definition at line 66 of file Chunker.h.

Constructor & Destructor Documentation

Chunker()

lsst::sphgeom::Chunker::Chunker	(	int32_t	numStripes,
		int32_t	numSubStripesPerStripe
	)

Definition at line 57 of file Chunker.cc.

                                                 :
    _numStripes(numStripes),
    _numSubStripesPerStripe(numSubStripesPerStripe),
    _numSubStripes(numStripes * numSubStripesPerStripe),
    _maxSubChunksPerSubStripeChunk(0),
    _subStripeHeight(Angle(PI) / _numSubStripes)
{
    if (numStripes < 1 || numSubStripesPerStripe < 1) {
        throw std::runtime_error("The number of stripes and sub-stripes "
                                 "per stripe must be positive");
    }
    if (numStripes * numSubStripesPerStripe > 180*3600) {
        throw std::runtime_error("Sub-stripes are too small");
    }
    Angle const stripeHeight = Angle(PI) / _numStripes;
    _stripes.reserve(_numStripes);
    _subStripes.reserve(_numSubStripes);
    for (int32_t s = 0; s < _numStripes; ++s) {
        // Compute stripe latitude bounds.
        AngleInterval sLat(s * stripeHeight - Angle(0.5 * PI),
                           (s + 1) * stripeHeight - Angle(0.5 * PI));
        Stripe stripe;
        int32_t const nc = computeNumSegments(sLat, stripeHeight);
        stripe.chunkWidth = Angle(2.0 * PI) / nc;
        stripe.numChunksPerStripe = nc;
        int32_t ss = s * _numSubStripesPerStripe;
        int32_t const ssEnd = ss + _numSubStripesPerStripe;
        for (; ss < ssEnd; ++ss) {
            // Compute sub-stripe latitude bounds.
            AngleInterval ssLat(ss * _subStripeHeight - Angle(0.5 * PI),
                                (ss + 1) * _subStripeHeight - Angle(0.5 * PI));
            SubStripe subStripe;
            int32_t const nsc = computeNumSegments(ssLat, _subStripeHeight) / nc;
            stripe.numSubChunksPerChunk += nsc;
            subStripe.numSubChunksPerChunk = nsc;
            if (nsc > _maxSubChunksPerSubStripeChunk) {
                _maxSubChunksPerSubStripeChunk = nsc;
            }
            subStripe.subChunkWidth = Angle(2.0 * PI) / (nsc * nc);
            _subStripes.push_back(subStripe);
        }
        _stripes.push_back(stripe);
    }
}

Member Function Documentation

getAllChunks()

std::vector< int32_t > lsst::sphgeom::Chunker::getAllChunks

(

)

const

getAllChunks returns the complete set of chunk IDs for the unit sphere.

Definition at line 258 of file Chunker.cc.

                                               {
    std::vector<int32_t> chunkIds;
    for (int32_t s = 0; s < _numStripes; ++s) {
        int32_t nc = _stripes[s].numChunksPerStripe;
        for (int32_t c = 0; c < nc; ++c) {
            chunkIds.push_back(_getChunkId(s, c));
        }
    }
    return chunkIds;
}

getAllSubChunks()

std::vector< int32_t > lsst::sphgeom::Chunker::getAllSubChunks

(

int32_t

chunkId

)

const

getAllSubChunks returns the complete set of sub-chunk IDs for the given chunk.

Definition at line 269 of file Chunker.cc.

                                                                 {
    std::vector<int32_t> subChunkIds;
    int32_t s = getStripe(chunkId);
    subChunkIds.reserve(_stripes.at(s).numSubChunksPerChunk);
    int32_t const ssBeg = s * _numSubStripesPerStripe;
    int32_t const ssEnd = ssBeg + _numSubStripesPerStripe;
    for (int32_t ss = ssBeg; ss < ssEnd; ++ss) {
        int32_t const scEnd = _subStripes[ss].numSubChunksPerChunk;
        int32_t const subChunkIdBase = _maxSubChunksPerSubStripeChunk * (ss - ssBeg);
        for (int32_t sc = 0; sc < scEnd; ++sc) {
            subChunkIds.push_back(subChunkIdBase + sc);
        }
    }
    return subChunkIds;
}

getChunk()

int32_t lsst::sphgeom::Chunker::getChunk ( int32_t  chunkId, int32_t  stripe  ) const

inline

Return the chunk for the given chunkId and stripe.

Definition at line 121 of file Chunker.h.

                                                            {
        return chunkId - stripe*2*_numStripes;
    }

getChunkBoundingBox()

Box lsst::sphgeom::Chunker::getChunkBoundingBox	(	int32_t	stripe,
		int32_t	chunk
	)		const

Definition at line 291 of file Chunker.cc.

                                                                    {
    Angle chunkWidth = _stripes[stripe].chunkWidth;
    NormalizedAngleInterval lon(chunkWidth * chunk,
                                chunkWidth * (chunk + 1));
    int32_t ss = stripe * _numSubStripesPerStripe;
    int32_t ssEnd = ss + _numSubStripesPerStripe;
    AngleInterval lat(ss * _subStripeHeight - Angle(0.5 * PI),
                      ssEnd * _subStripeHeight - Angle(0.5 * PI));
    return Box(lon, lat).dilatedBy(Angle(BOX_EPSILON));
}

getChunksIntersecting()

std::vector< int32_t > lsst::sphgeom::Chunker::getChunksIntersecting

(

Region const &

r

)

const

getChunksIntersecting returns all the chunks that potentially intersect the given region.

Definition at line 103 of file Chunker.cc.

                                                                        {
    std::vector<int32_t> chunkIds;
    // Find the stripes that intersect the bounding box of r.
    Box b = r.getBoundingBox().dilatedBy(Angle(BOX_EPSILON));
    double ya = std::floor((b.getLat().getA() + Angle(0.5 * PI)) / _subStripeHeight);
    double yb = std::floor((b.getLat().getB() + Angle(0.5 * PI)) / _subStripeHeight);
    int32_t minSS = std::min(static_cast<int32_t>(ya), _numSubStripes - 1);
    int32_t maxSS = std::min(static_cast<int32_t>(yb), _numSubStripes - 1);
    int32_t minS = minSS / _numSubStripesPerStripe;
    int32_t maxS = maxSS / _numSubStripesPerStripe;
    for (int32_t s = minS; s <= maxS; ++s) {
        // Find the chunks of s that intersect the bounding box of r.
        Angle chunkWidth = _stripes[s].chunkWidth;
        int32_t nc = _stripes[s].numChunksPerStripe;
        double xa = std::floor(b.getLon().getA() / chunkWidth);
        double xb = std::floor(b.getLon().getB() / chunkWidth);
        int32_t ca = std::min(static_cast<int32_t>(xa), nc - 1);
        int32_t cb = std::min(static_cast<int32_t>(xb), nc - 1);
        if (ca == cb && b.getLon().wraps()) {
            ca = 0;
            cb = nc - 1;
        }
        // Examine each chunk overlapping the bounding box of r.
        if (ca <= cb) {
            for (int32_t c = ca; c <= cb; ++c) {
                if ((r.relate(getChunkBoundingBox(s, c)) & DISJOINT) == 0) {
                    chunkIds.push_back(_getChunkId(s, c));
                }
            }
        } else {
            for (int32_t c = 0; c <= cb; ++c) {
                if ((r.relate(getChunkBoundingBox(s, c)) & DISJOINT) == 0) {
                    chunkIds.push_back(_getChunkId(s, c));
                }
            }
            for (int32_t c = ca; c < nc; ++c) {
                if ((r.relate(getChunkBoundingBox(s, c)) & DISJOINT) == 0) {
                    chunkIds.push_back(_getChunkId(s, c));
                }
            }
        }
    }
    return chunkIds;
}

getNumStripes()

int32_t lsst::sphgeom::Chunker::getNumStripes ( ) const

inline

getNumStripes returns the number of fixed-height latitude intervals in the sky subdivision.

Definition at line 83 of file Chunker.h.

                                  {
        return _numStripes;
    }

getNumSubStripesPerStripe()

int32_t lsst::sphgeom::Chunker::getNumSubStripesPerStripe ( ) const

inline

getNumSubStripesPerStripe returns the number of fixed-height latitude sub-intervals in each stripe.

Definition at line 89 of file Chunker.h.

                                              {
        return _numSubStripesPerStripe;
    }

getStripe()

int32_t lsst::sphgeom::Chunker::getStripe ( int32_t  chunkId ) const

inline

Return the stripe for the specified chunkId.

Definition at line 116 of file Chunker.h.

                                             {
        return chunkId / (2 * _numStripes);
    }

getSubChunkBoundingBox()

Box lsst::sphgeom::Chunker::getSubChunkBoundingBox	(	int32_t	subStripe,
		int32_t	subChunk
	)		const

Definition at line 302 of file Chunker.cc.

                                                                             {
    Angle subChunkWidth = _subStripes[subStripe].subChunkWidth;
    NormalizedAngleInterval lon(subChunkWidth * subChunk,
                                subChunkWidth * (subChunk + 1));
    AngleInterval lat(subStripe * _subStripeHeight - Angle(0.5 * PI),
                      (subStripe + 1) * _subStripeHeight - Angle(0.5 * PI));
    return Box(lon, lat).dilatedBy(Angle(BOX_EPSILON));
}

getSubChunksIntersecting()

std::vector< SubChunks > lsst::sphgeom::Chunker::getSubChunksIntersecting

(

Region const &

r

)

const

getSubChunksIntersecting returns all the sub-chunks that potentially intersect the given region.

Definition at line 148 of file Chunker.cc.

{
    std::vector<SubChunks> chunks;
    // Find the stripes that intersect the bounding box of r.
    Box b = r.getBoundingBox().dilatedBy(Angle(BOX_EPSILON));
    double ya = std::floor((b.getLat().getA() + Angle(0.5 * PI)) / _subStripeHeight);
    double yb = std::floor((b.getLat().getB() + Angle(0.5 * PI)) / _subStripeHeight);
    int32_t minSS = std::min(static_cast<int32_t>(ya), _numSubStripes - 1);
    int32_t maxSS = std::min(static_cast<int32_t>(yb), _numSubStripes - 1);
    int32_t minS = minSS / _numSubStripesPerStripe;
    int32_t maxS = maxSS / _numSubStripesPerStripe;
    for (int32_t s = minS; s <= maxS; ++s) {
        // Find the chunks of s that intersect the bounding box of r.
        Angle chunkWidth = _stripes[s].chunkWidth;
        int32_t nc = _stripes[s].numChunksPerStripe;
        double xa = std::floor(b.getLon().getA() / chunkWidth);
        double xb = std::floor(b.getLon().getB() / chunkWidth);
        int32_t ca = std::min(static_cast<int32_t>(xa), nc - 1);
        int32_t cb = std::min(static_cast<int32_t>(xb), nc - 1);
        if (ca == cb && b.getLon().wraps()) {
            ca = 0;
            cb = nc - 1;
        }
        // Examine sub-chunks for each chunk overlapping the bounding box of r.
        if (ca <= cb) {
            for (int32_t c = ca; c <= cb; ++c) {
                _getSubChunks(chunks, r, b.getLon(), s, c, minSS, maxSS);
            }
        } else {
            for (int32_t c = 0; c <= cb; ++c) {
                _getSubChunks(chunks, r, b.getLon(), s, c, minSS, maxSS);
            }
            for (int32_t c = ca; c < nc; ++c) {
                _getSubChunks(chunks, r, b.getLon(), s, c, minSS, maxSS);
            }
        }
    }
    return chunks;
}

operator!=()

bool lsst::sphgeom::Chunker::operator!= ( Chunker const &  c ) const

inline

Definition at line 76 of file Chunker.h.

                                             {
        return _numStripes != c._numStripes ||
               _numSubStripesPerStripe != c._numSubStripesPerStripe;
    }

operator==()

bool lsst::sphgeom::Chunker::operator== ( Chunker const &  c ) const

inline

Definition at line 71 of file Chunker.h.

                                             {
        return _numStripes == c._numStripes &&
               _numSubStripesPerStripe == c._numSubStripesPerStripe;
    }

valid()

bool lsst::sphgeom::Chunker::valid

(

int32_t

chunkId

)

const

Return 'true' if the specified chunk number is valid.

Definition at line 285 of file Chunker.cc.

                                         {
    int32_t const s = getStripe(chunkId);
    return s >= 0 and s < _numStripes and
           getChunk(chunkId, s) < _stripes.at(s).numChunksPerStripe;
}

---

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

• /j/snowflake/release/lsstsw/stack/cb4e2dc/Linux64/sphgeom/20.0.0-5-gfbfe500+d529cf1a41/include/lsst/sphgeom/Chunker.h
• /j/snowflake/release/lsstsw/stack/cb4e2dc/Linux64/sphgeom/20.0.0-5-gfbfe500+d529cf1a41/src/Chunker.cc