lsst::afw::geom::SpanSet Class Reference

A compact representation of a collection of pixels. More...

#include <SpanSet.h>

Inheritance diagram for lsst::afw::geom::SpanSet:

Public Types
using	const_iterator = std::vector<Span>::const_iterator
using	size_type = std::vector<Span>::size_type
using	value_type = Span
using	const_reference = const value_type &

Public Member Functions
const_iterator	begin () const
const_iterator	end () const
const_iterator	cbegin () const
const_iterator	cend () const
const_reference	front () const
const_reference	back () const
size_type	size () const
bool	empty () const
	SpanSet ()
	Default constructor.
	SpanSet (lsst::geom::Box2I const &box)
	Construct a SpanSet from a box.
template<typename iter >
	SpanSet (iter begin, iter end, bool normalize=true)
	Construct a SpanSet from an iterator.
	SpanSet (std::vector< Span > const &vec, bool normalize=true)
	Construct a SpanSet from a std vector by copying.
	SpanSet (std::vector< Span > &&vec, bool normalize=true)
	Construct a SpanSet from a std vector from a move.
	SpanSet (SpanSet const &other)=delete
	SpanSet (SpanSet &&other)=delete
	~SpanSet () override=default
SpanSet &	operator= (SpanSet const &)=default
SpanSet &	operator= (SpanSet &&other)
size_type	getArea () const
	Return the number of pixels in the SpanSet.
lsst::geom::Box2I	getBBox () const
	Return a new integer box which is the minimum size to contain the pixels.
bool	isContiguous () const
	Defines if the SpanSet is simply contiguous.
std::shared_ptr< SpanSet >	shiftedBy (int x, int y) const
	Return a new SpanSet shifted by specified amount.
std::shared_ptr< SpanSet >	shiftedBy (lsst::geom::Extent2I const &offset) const
	Return a new SpanSet shifted by specified amount.
std::shared_ptr< SpanSet >	clippedTo (lsst::geom::Box2I const &box) const
	Return a new SpanSet which has all pixel values inside specified box.
std::shared_ptr< SpanSet >	transformedBy (lsst::geom::LinearTransform const &t) const
	Return a new SpanSet who's pixels are the product of applying the specified transformation.
std::shared_ptr< SpanSet >	transformedBy (lsst::geom::AffineTransform const &t) const
	Return a new SpanSet who's pixels are the product of applying the specified transformation.
std::shared_ptr< SpanSet >	transformedBy (TransformPoint2ToPoint2 const &t) const
	Return a new SpanSet who's pixels are the product of applying the specified transformation.
bool	overlaps (SpanSet const &other) const
	Specifies if this SpanSet overlaps with another SpanSet.
bool	contains (SpanSet const &other) const
	Check if a SpanSet instance entirely contains another SpanSet.
bool	contains (lsst::geom::Point2I const &point) const
	Check if a point is contained within the SpanSet instance.
lsst::geom::Point2D	computeCentroid () const
	Compute the point about which the SpanSet's first moment is zero.
ellipses::Quadrupole	computeShape () const
	Compute the shape parameters for the distribution of points in the SpanSet.
std::shared_ptr< SpanSet >	dilated (int r, Stencil s=Stencil::CIRCLE) const
	Perform a set dilation operation, and return a new object.
std::shared_ptr< SpanSet >	dilated (SpanSet const &other) const
	Perform a set dilation operation, and return a new object.
std::shared_ptr< SpanSet >	eroded (int r, Stencil s=Stencil::CIRCLE) const
	Perform a set erosion, and return a new object.
std::shared_ptr< SpanSet >	eroded (SpanSet const &other) const
	Perform a set erosion operation, and return a new object.
template<typename Pixel , int inN, int inC>
ndarray::Array< typename std::remove_const< Pixel >::type, inN - 1, inN - 1 >	flatten (ndarray::Array< Pixel, inN, inC > const &input, lsst::geom::Point2I const &xy0=lsst::geom::Point2I()) const
	Reduce the pixel dimensionality from 2 to 1 of an array at points given by SpanSet.
template<typename PixelIn , typename PixelOut , int inA, int outC, int inC>
void	flatten (ndarray::Array< PixelOut, inA - 1, outC > const &output, ndarray::Array< PixelIn, inA, inC > const &input, lsst::geom::Point2I const &xy0=lsst::geom::Point2I()) const
	Reduce the pixel dimensionality from 2 to 1 of an array at points given by SpanSet.
template<typename Pixel , int inA, int inC>
ndarray::Array< typename std::remove_const< Pixel >::type, inA+1, inA+1 >	unflatten (ndarray::Array< Pixel, inA, inC > const &input) const
	Expand an array by one spatial dimension at points given by SpanSet.
template<typename PixelIn , typename PixelOut , int inA, int outC, int inC>
void	unflatten (ndarray::Array< PixelOut, inA+1, outC > const &output, ndarray::Array< PixelIn, inA, inC > const &input, lsst::geom::Point2I const &xy0=lsst::geom::Point2I()) const
	Expand an array by one spatial dimension at points given by SpanSet.
template<typename ImageT >
void	copyImage (image::Image< ImageT > const &src, image::Image< ImageT > &dest)
	Copy contents of source Image into destination image at the positions defined in the SpanSet.
template<typename ImageT , typename MaskT , typename VarT >
void	copyMaskedImage (image::MaskedImage< ImageT, MaskT, VarT > const &src, image::MaskedImage< ImageT, MaskT, VarT > &dest)
	Copy contents of source MaskedImage into destination image at the positions defined in the SpanSet.
template<typename ImageT >
void	setImage (image::Image< ImageT > &image, ImageT val, lsst::geom::Box2I const &region=lsst::geom::Box2I(), bool doClip=false) const
	Set the values of an Image at points defined by the SpanSet.
template<typename Functor , typename... Args>
void	applyFunctor (Functor &&func, Args &&... args) const
	Apply functor on individual elements from the supplied parameters.
template<typename T >
void	setMask (lsst::afw::image::Mask< T > &target, T bitmask) const
	Set a Mask at pixels defined by the SpanSet.
template<typename T >
void	clearMask (lsst::afw::image::Mask< T > &target, T bitmask) const
	Unset a Mask at pixels defined by the SpanSet.
std::shared_ptr< SpanSet >	intersect (SpanSet const &other) const
	Determine the common points between two SpanSets, and create a new SpanSet.
template<typename T >
std::shared_ptr< SpanSet >	intersect (image::Mask< T > const &other, T bitmask) const
	Determine the common points between a SpanSet and a Mask with a given bit pattern.
std::shared_ptr< SpanSet >	intersectNot (SpanSet const &other) const
	Determine the common points between a SpanSet and the logical inverse of a second SpanSet and return them in a new SpanSet.
template<typename T >
std::shared_ptr< SpanSet >	intersectNot (image::Mask< T > const &other, T bitmask) const
	Determine the common points between a SpanSet and the logical inverse of a Mask for a given bit pattern.
std::shared_ptr< SpanSet >	union_ (SpanSet const &other) const
	Create a new SpanSet that contains all points from two SpanSets.
template<typename T >
std::shared_ptr< SpanSet >	union_ (image::Mask< T > const &other, T bitmask) const
	Determine the union between a SpanSet and a Mask for a given bit pattern.
bool	operator== (SpanSet const &other) const
	Compute equality between two SpanSets.
bool	operator!= (SpanSet const &other) const
std::vector< std::shared_ptr< geom::SpanSet > >	split () const
	Split a discontinuous SpanSet into multiple SpanSets which are contiguous.
bool	isPersistable () const noexcept override
	Return true if this particular object can be persisted using afw::table::io.
std::shared_ptr< geom::SpanSet >	findEdgePixels () const
	Select pixels within the SpanSet which touch its edge.
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file.
void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory.
void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object.

Static Public Member Functions
static std::shared_ptr< geom::SpanSet >	fromShape (int r, Stencil s=Stencil::CIRCLE, lsst::geom::Point2I offset=lsst::geom::Point2I())
	Factory function for creating SpanSets from a Stencil.
static std::shared_ptr< geom::SpanSet >	fromShape (geom::ellipses::Ellipse const &ellipse)
	Factory function for creating SpanSets from an ellipse object.
template<typename T , typename UnaryPredicate = details::AnyBitSetFunctor<T>>
static std::shared_ptr< geom::SpanSet >	fromMask (image::Mask< T > const &mask, UnaryPredicate comparator=details::AnyBitSetFunctor< T >())
	Create a SpanSet from a mask.
template<typename T >
static std::shared_ptr< geom::SpanSet >	fromMask (image::Mask< T > const &mask, T bitmask)
	Create a SpanSet from a mask.
static std::shared_ptr< lsst::afw::geom::SpanSet >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object.
static std::shared_ptr< lsst::afw::geom::SpanSet >	readFits (std::string const &fileName, int hdu=fits::DEFAULT_HDU)
	Read an object from a regular FITS file.
static std::shared_ptr< lsst::afw::geom::SpanSet >	readFits (fits::MemFileManager &manager, int hdu=fits::DEFAULT_HDU)
	Read an object from a FITS file in memory.
static std::shared_ptr< lsst::afw::geom::SpanSet >	dynamicCast (std::shared_ptr< Persistable > const &ptr)
	Dynamically cast a shared_ptr.

Protected Types
using	OutputArchiveHandle = io::OutputArchiveHandle

Private Member Functions
std::string	getPersistenceName () const override
	Return the unique name used to persist this object and look up its factory.
std::string	getPythonModule () const override
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.
void	write (OutputArchiveHandle &handle) const override
	Write the object to one or more catalogs.

Friends
class	SpansSetFactory

Detailed Description

A compact representation of a collection of pixels.

A SpanSet is a collection of Span classes. As each Span encodes a range of pixels on a given row, a SpanSet represents an arbitrary collection of pixels on an image. The SpanSet class also contains mathematical set style operators, for working with the collection of pixels, and helper functions which make use of the area defined to perform localized actions

Definition at line 77 of file SpanSet.h.

Member Typedef Documentation

const_iterator

using lsst::afw::geom::SpanSet::const_iterator = std::vector<Span>::const_iterator

Definition at line 80 of file SpanSet.h.

const_reference

using lsst::afw::geom::SpanSet::const_reference = const value_type &

Definition at line 83 of file SpanSet.h.

OutputArchiveHandle

using lsst::afw::table::io::Persistable::OutputArchiveHandle = io::OutputArchiveHandle

protectedinherited

Definition at line 108 of file Persistable.h.

size_type

using lsst::afw::geom::SpanSet::size_type = std::vector<Span>::size_type

Definition at line 81 of file SpanSet.h.

value_type

using lsst::afw::geom::SpanSet::value_type = Span

Definition at line 82 of file SpanSet.h.

Constructor & Destructor Documentation

SpanSet() [1/7]

lsst::afw::geom::SpanSet::SpanSet

(

)

Default constructor.

Construct a null SpanSet, with zero size. This is useful as a placeholder

Definition at line 177 of file SpanSet.cc.

: _spanVector(), _bbox(), _area(0) {}

SpanSet() [2/7]

lsst::afw::geom::SpanSet::SpanSet ( lsst::geom::Box2I const & box )

explicit

Construct a SpanSet from a box.

Parameters

box	A integer box that defines the shape for which a span set should be created

Definition at line 180 of file SpanSet.cc.

                                         : _bbox(box), _area(box.getArea()) {
    int beginY = box.getMinY();
 
    int beginX = box.getMinX();
    int maxX = box.getMaxX();
 
    for (int i = beginY; i < _bbox.getEndY(); ++i) {
        _spanVector.emplace_back(i, beginX, maxX);
    }
}

SpanSet() [3/7]

template<typename iter >

lsst::afw::geom::SpanSet::SpanSet ( iter begin, iter end, bool normalize = true )

inline

Construct a SpanSet from an iterator.

This constructor accepts the begin and end points of an arbitrary iterator of a container which contains previously created Spans. These Spans are used to construct the SpanSet.

Parameters

begin	Beginning iterator of a container of Spans
end	End iterator of a container of Spans
normalize	Controls if the constructor attempts to merge connected or overlapping spans. Defaults to true. Set to false to save computational time when the container is sure to already be normalized.

Definition at line 123 of file SpanSet.h.

                                                         : _spanVector(begin, end) {
        // Return a null SpanSet if spanVector is 0
        if (_spanVector.size() == 0) {
            _bbox = lsst::geom::Box2I();
            _area = 0;
        } else {
            if (normalize) {
                _runNormalize();
            }
            _initialize();
        }
    }

SpanSet() [4/7]

lsst::afw::geom::SpanSet::SpanSet ( std::vector< Span > const & vec, bool normalize = true )

explicit

Construct a SpanSet from a std vector by copying.

This constructor accepts a standard vector which contains already created Spans. These Spans are copied into the internal container of spans.

Parameters

vec	Standard vector containing Spans
normalize	Controls if the constructor attempts to merge connected or overlapping spans. Defaults to true. Set to false to save computational time when the container is sure to already be normalized.

Definition at line 192 of file SpanSet.cc.

                                                           : _spanVector(vec) {
    // If the incoming vector is zero, should create an empty spanSet
    if (_spanVector.empty()) {
        _bbox = lsst::geom::Box2I();
        _area = 0;
    } else {
        if (normalize) {
            _runNormalize();
        }
        _initialize();
    }
}

SpanSet() [5/7]

lsst::afw::geom::SpanSet::SpanSet ( std::vector< Span > && vec, bool normalize = true )

explicit

Construct a SpanSet from a std vector from a move.

This constructor accepts a standard vector r-reference which contains already created Spans. These Spans become the internal container of spans.

Parameters

vec	Standard vector containing Spans
normalize	Controls if the constructor attempts to merge connected or overlapping spans. Defaults to true. Set to false to save computational time when the container is sure to already be normalized.

Definition at line 206 of file SpanSet.cc.

                                                      : _spanVector(std::move(vec)) {
    // If the incoming vector is zero, should create an empty SpanSet
    if (_spanVector.size() == 0) {
        _bbox = lsst::geom::Box2I();
        _area = 0;
    } else {
        if (normalize) {
            _runNormalize();
        }
        _initialize();
    }
}

SpanSet() [6/7]

lsst::afw::geom::SpanSet::SpanSet ( SpanSet const & other )

delete

SpanSet() [7/7]

lsst::afw::geom::SpanSet::SpanSet ( SpanSet && other )

delete

~SpanSet()

lsst::afw::geom::SpanSet::~SpanSet ( )

overridedefault

Member Function Documentation

applyFunctor()

template<typename Functor , typename... Args>

void lsst::afw::geom::SpanSet::applyFunctor ( Functor && func, Args &&... args ) const

inline

Apply functor on individual elements from the supplied parameters.

Use a variadic template to take a functor object, and an arbitrary number of parameters. Parameters may be of type(s) Image, MakedImage, ndarray, numeric value and generic iterators. For most of these types bound checking is done to ensure execution safety, but because a generic iterator can have any behavior, bounds checking is not possible. As such the iterator must be valid for at least the number of pixels contained in the SpanSet. Numeric values are also different in that they will not be iterated but the value will be passed to the functor for each point in the SpanSet.

Because a ndarray can either be interpreted as either a two dimensional image, or a one dimensional vector a user must break the ambiguity by using the functions ndarray::ndImage, or ndarray::ndFlat respectively.

The functor object must operate in-place on any data, no return values are captured. No exceptions are handled, if a functor throws one it will propagate back out of the applyFunctor call, possibly leaving the output array in an incomplete state. The first argument of the functor must be a lsst::geom::Point2I which will be the point in the SpanSet where the operation is occurring. All the remaining arguments to the functor will be individual values generated from the input arguments. For two dimensional types (Image, MaskedImage, ndarray) arguments will be the value taken from the input type at the location given by the SpanSet. I.e. if the SpanSet has the point (2,3) in it, then a 2 dimensional ndarray will have ndarray[2][3] passed to the functor. Thus all SpanSet coordinates must be addressable in two dimensional types. For one dimensional types (ndarray, iterator) arguments will correspond to the value at the location defined by number of pixels which have been iterated over. I.e. if there are 3 pixels defined in the SpanSet a one dimensional ndarray will have the value ndarray[0] passed to the functor on on the first functor call, ndarray[1] passed on the second call, and ndarray[2] passed on the last functor call. The total length of a one dimensional type will be equal to the area of the SpanSet, and therefore the data-type must be at least that length. The order of the parameters supplied to the functor will be the same order as they are passed to the applyFunctor method.

Template Parameters

...Args

Variadic type specification

Parameters

func	Functor that is to be applied on each of the values taken from ...args.
...args	Variadic arguments, may be of type Image, MaskedImage, ndarrays, numeric values and iterators. ndarrays must be specified as either image or vector with the ndarray::ndImage or ndarray::ndFlat functions

Definition at line 512 of file SpanSet.h.

                                                             {
        /* Use a variadic template to take a functor object, and an arbitrary number
           of parameters. For each of the arguments, construct a Getter class using
           a function (makeGetter) which is overloaded to all the types applyFunctorImpl
           supports: Images, MaskedImages, Exposures, ndarrays, numeric values, and
           iterators. The functor and the getters are then passed to the implementation of
           applyFunctor where the values of the input arguments are intelligently
           generated at each point in SpanSet, and passed to the functor object for evaluation.
         */
        applyFunctorImpl(func, details::makeGetter(args)...);
    }

back()

const_reference lsst::afw::geom::SpanSet::back ( ) const

inline

Definition at line 93 of file SpanSet.h.

{ return const_cast<geom::Span &>(_spanVector.back()); }

begin()

const_iterator lsst::afw::geom::SpanSet::begin ( ) const

inline

Definition at line 88 of file SpanSet.h.

{ return _spanVector.cbegin(); }

cbegin()

const_iterator lsst::afw::geom::SpanSet::cbegin ( ) const

inline

Definition at line 90 of file SpanSet.h.

{ return _spanVector.cbegin(); }

cend()

const_iterator lsst::afw::geom::SpanSet::cend ( ) const

inline

Definition at line 91 of file SpanSet.h.

{ return _spanVector.cend(); }

clearMask()

template<typename T >

void lsst::afw::geom::SpanSet::clearMask	(	lsst::afw::image::Mask< T > &	target,
		T	bitmask ) const

Unset a Mask at pixels defined by the SpanSet.

Template Parameters

T	data-type of a pixel in the Mask plane

Parameters

[in,out]	target	Mask in which a bit pattern will be unset
[in]	bitmask	The bit pattern to clear in the mask

Definition at line 956 of file SpanSet.cc.

                                                             {
    // Use a lambda to clear bits in a mask at the locations given by SpanSet
    auto targetArray = target.getArray();
    auto xy0 = target.getBBox().getMin();
    auto clearMaskFunctor = [](lsst::geom::Point2I const& point,
                               typename details::ImageNdGetter<T, 2, 1>::Reference maskVal,
                               T bitmask) { maskVal &= ~bitmask; };
    applyFunctor(clearMaskFunctor, ndarray::ndImage(targetArray, xy0), bitmask);
}

clippedTo()

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::clippedTo

(

lsst::geom::Box2I const &

box

)

const

Return a new SpanSet which has all pixel values inside specified box.

Parameters

box	Integer box specifying the bounds for which all pixels must be within

Definition at line 439 of file SpanSet.cc.

                                                                        {
    /* Return a copy of the current SpanSet but only with values which are contained within
     * the supplied box
     */
    std::vector<Span> tempVec;
    for (auto const& spn : _spanVector) {
        if (spn.getY() >= box.getMinY() && spn.getY() <= box.getMaxY() &&
            spansOverlap(spn, Span(spn.getY(), box.getMinX(), box.getMaxX()))) {
            tempVec.emplace_back(spn.getY(), std::max(box.getMinX(), spn.getMinX()),
                                   std::min(box.getMaxX(), spn.getMaxX()));
        }
    }
    return std::make_shared<SpanSet>(std::move(tempVec), false);
}

computeCentroid()

lsst::geom::Point2D lsst::afw::geom::SpanSet::computeCentroid

(

)

const

Compute the point about which the SpanSet's first moment is zero.

Definition at line 502 of file SpanSet.cc.

                                               {
    // Find the centroid of the SpanSet
    std::size_t n = 0;
    double xc = 0, yc = 0;
    for (auto const& spn : _spanVector) {
        int const y = spn.getY();
        int const x0 = spn.getMinX();
        int const x1 = spn.getMaxX();
        int const npix = x1 - x0 + 1;
 
        n += npix;
        xc += npix * 0.5 * (x1 + x0);
        yc += npix * y;
    }
    assert(n == _area);
 
    return lsst::geom::Point2D(xc / _area, yc / _area);
}

computeShape()

ellipses::Quadrupole lsst::afw::geom::SpanSet::computeShape

(

)

const

Compute the shape parameters for the distribution of points in the SpanSet.

Definition at line 521 of file SpanSet.cc.

                                               {
    // Compute the shape of the SpanSet
    lsst::geom::Point2D cen = computeCentroid();
    double const xc = cen.getX();
    double const yc = cen.getY();
 
    double sumxx = 0, sumxy = 0, sumyy = 0;
    for (auto const& spn : _spanVector) {
        int const y = spn.getY();
        int const x0 = spn.getX0();
        int const x1 = spn.getX1();
        int const npix = x1 - x0 + 1;
 
        for (int x = x0; x <= x1; ++x) {
            sumxx += (x - xc) * (x - xc);
        }
        sumxy += npix * (0.5 * (x1 + x0) - xc) * (y - yc);
        sumyy += npix * (y - yc) * (y - yc);
    }
 
    return ellipses::Quadrupole(sumxx / _area, sumyy / _area, sumxy / _area);
}

contains() [1/2]

bool lsst::afw::geom::SpanSet::contains

(

lsst::geom::Point2I const &

point

)

const

Check if a point is contained within the SpanSet instance.

Parameters

point

An integer point object for which membership is to be tested

Definition at line 492 of file SpanSet.cc.

                                                         {
    // Check to see if a given point is found within any spans in this
    for (auto& spn : _spanVector) {
        if (spn.contains(point)) {
            return true;
        }
    }
    return false;
}

contains() [2/2]

bool lsst::afw::geom::SpanSet::contains

(

SpanSet const &

other

)

const

Check if a SpanSet instance entirely contains another SpanSet.

Parameters

other

The SpanSet who's membership is to be tested for

Definition at line 466 of file SpanSet.cc.

                                                 {
    // Handle null SpanSet passed as other
    if (other.empty()) {
        return false;
    }
    // Function to check if a SpanSet is entirely contained within this
    for (auto const& otherSpn : other) {
        std::size_t counter = 0;
        for (auto const& spn : _spanVector) {
            // Check that the end points of the span from other are contained in the
            // span from this
            if (spn.contains(lsst::geom::Point2I(otherSpn.getMinX(), otherSpn.getY())) &&
                spn.contains(lsst::geom::Point2I(otherSpn.getMaxX(), otherSpn.getY()))) {
                ++counter;
            }
        }
        // if counter is equal to zero, then the current span from other is not
        // contained in any span in this, and the function should return false
        // short circuiting any other spans from other
        if (counter == 0) {
            return false;
        }
    }
    return true;
}

copyImage()

template<typename ImageT >

void lsst::afw::geom::SpanSet::copyImage ( image::Image< ImageT > const & src, image::Image< ImageT > & dest )

inline

Copy contents of source Image into destination image at the positions defined in the SpanSet.

Template Parameters

ImageT

The pixel type of the Image

Parameters

[in]	src	The Image that pixel values will be taken from
[out]	dest	The Image where pixels will be copied

Definition at line 416 of file SpanSet.h.

                                                                            {
        auto copyFunc = [](lsst::geom::Point2I const &point, ImageT const &srcPix, ImageT &destPix) {
            destPix = srcPix;
        };
        applyFunctor(copyFunc, src, dest);
    }

copyMaskedImage()

template<typename ImageT , typename MaskT , typename VarT >

void lsst::afw::geom::SpanSet::copyMaskedImage ( image::MaskedImage< ImageT, MaskT, VarT > const & src, image::MaskedImage< ImageT, MaskT, VarT > & dest )

inline

Copy contents of source MaskedImage into destination image at the positions defined in the SpanSet.

Template Parameters

ImageT	The pixel type of the MaskedImage's Image
MaskT	The pixel type of the MaskedImage's Mask
VarT	The Pixel type of the MaskedImage's Variance Image

Parameters

[in]	src	The MaskedImage that pixel values will be taken from
[out]	dest	The MaskedImage where pixels will be copied

Definition at line 433 of file SpanSet.h.

                                                                      {
        auto copyFunc = [](lsst::geom::Point2I const &point, ImageT const &srcPix, MaskT const &srcMask,
                           VarT const &srcVar, ImageT &destPix, MaskT &destMask, VarT &destVar) {
            destPix = srcPix;
            destMask = srcMask;
            destVar = srcVar;
        };
        applyFunctor(copyFunc, *(src.getImage()), *(src.getMask()), *(src.getVariance()), *(dest.getImage()),
                     *(dest.getMask()), *(dest.getVariance()));
    }

dilated() [1/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::dilated	(	int	r,
		Stencil	s = Stencil::CIRCLE ) const

Perform a set dilation operation, and return a new object.

Dilate a SpanSet with a kernel specified with the stencil parameter

Parameters

r	radius of the stencil, the length is inclusive i.e. 3 ranges from -3 to 3
s	must be an enumeration of type geom::Stencil. Specifies the shape of the dilation kernel. May be CIRCLE, MANHATTAN, or BOX

Definition at line 544 of file SpanSet.cc.

                                                              {
    // Return a dilated SpanSet made with the given stencil, by creating a SpanSet
    // from the stencil and forwarding to the appropriate overloaded method
    std::shared_ptr<SpanSet> stencilToSpanSet = fromShape(r, s);
    return dilated(*stencilToSpanSet);
}

dilated() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::dilated

(

SpanSet const &

other

)

const

Perform a set dilation operation, and return a new object.

Dilate a SpanSet with a kernel specified by another SpanSet

Parameters

other

A SpanSet which specifies the kernel to use for dilation

Definition at line 551 of file SpanSet.cc.

                                                                  {
    // Handle a null SpanSet nothing should be dilated
    if (other.size() == 0) {
        return std::make_shared<SpanSet>(_spanVector.begin(), _spanVector.end(), false);
    }
 
    // Return a dilated Spanset by the given SpanSet
    std::vector<Span> tempVec;
 
    for (auto const& spn : _spanVector) {
        for (auto const& otherSpn : other) {
            int const xmin = spn.getMinX() + otherSpn.getMinX();
            int const xmax = spn.getMaxX() + otherSpn.getMaxX();
            int const yval = spn.getY() + otherSpn.getY();
            tempVec.emplace_back(yval, xmin, xmax);
        }
    }
    // Allow constructor to handle merging adjacent and overlapping spans
    return std::make_shared<SpanSet>(std::move(tempVec));
}

dynamicCast()

template std::shared_ptr< meas::extensions::psfex::PsfexPsf > lsst::afw::table::io::PersistableFacade< lsst::afw::geom::SpanSet >::dynamicCast ( std::shared_ptr< Persistable > const & ptr )

staticinherited

Dynamically cast a shared_ptr.

Dynamically cast a shared pointer and raise on failure.

You must provide an explicit template instantiation in the .cc file for each class that inherits from PersistableFacade. Designed to work around RTTI issues on macOS with hidden symbols;

Exceptions

lsst::pex::exceptions::LogicError

if the cast fails

param[in] ptr The pointer to be cast.

Returns

The cast pointer.

Exceptions

lsst::pex::exceptions::TypeError

If the dynamic cast fails.

Definition at line 218 of file Persistable.cc.

empty()

bool lsst::afw::geom::SpanSet::empty ( ) const

inline

Definition at line 95 of file SpanSet.h.

{ return _spanVector.empty(); }

end()

const_iterator lsst::afw::geom::SpanSet::end ( ) const

inline

Definition at line 89 of file SpanSet.h.

{ return _spanVector.cend(); }

eroded() [1/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::eroded	(	int	r,
		Stencil	s = Stencil::CIRCLE ) const

Perform a set erosion, and return a new object.

Erode a SpanSet with a kernel specified with the stencil parameter

Parameters

r	radius of the stencil, the length is inclusive i.e. 3 ranges from -3 to 3
s	must be an enumeration of type geom::Stencil. Specifies the shape of the erosion kernel. May be CIRCLE, MANHATTAN, or BOX

Definition at line 572 of file SpanSet.cc.

                                                             {
    // Return an eroded SpanSet made with the given stencil, by creating a SpanSet
    // from the stencil and forwarding to the appropriate overloaded method
    std::shared_ptr<SpanSet> stencilToSpanSet = fromShape(r, s);
    return eroded(*stencilToSpanSet);
}

eroded() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::eroded

(

SpanSet const &

other

)

const

Perform a set erosion operation, and return a new object.

Erode a SpanSet with a kernel specified by another SpanSet

Parameters

other

A SpanSet which specifies the kernel to use for erosion

Definition at line 579 of file SpanSet.cc.

                                                                 {
    // Handle a null SpanSet nothing should be eroded
    if (other.size() == 0 || this->size() == 0) {
        return std::make_shared<SpanSet>(_spanVector.begin(), _spanVector.end(), false);
    }
 
    // Return a SpanSet eroded by the given SpanSet
    std::vector<Span> tempVec;
 
    // Calculate all possible primary runs.
    std::vector<PrimaryRun> primaryRuns;
    for (auto const& spn : _spanVector) {
        int m = 0;
        for (auto const& otherSpn : other) {
            if ((otherSpn.getMaxX() - otherSpn.getMinX()) <= (spn.getMaxX() - spn.getMinX())) {
                int xmin = spn.getMinX() - otherSpn.getMinX();
                int xmax = spn.getMaxX() - otherSpn.getMaxX();
                int y = spn.getY() - otherSpn.getY();
                primaryRuns.push_back(PrimaryRun({m, y, xmin, xmax}));
            }
            ++m;
        }
    }
 
    // Iterate over the primary runs in such a way that we consider all values of m
    // for a given y, then all m for y+1 etc.
    std::sort(primaryRuns.begin(), primaryRuns.end(), comparePrimaryRun);
 
    for (int y = primaryRuns.front().y; y <= primaryRuns.back().y; ++y) {
        auto yRange = std::equal_range(primaryRuns.begin(), primaryRuns.end(), y, ComparePrimaryRunY());
 
        /* Discard runs for any value of y for which we find fewer groups than M,
         * the total Y range of the structuring element. This is step 3.1 of the
         * Kim et al. algorithm.
         */
        // Plus one because end points are inclusive
        auto otherYRange = other.back().getY() - other.front().getY() + 1;
        if (std::distance(yRange.first, yRange.second) < otherYRange) {
            continue;
        }
 
        /* "good" runs are those which are covered by each value of m, ie by each
         * row in the structuring element. Our algorithm will consider each value
         * of m in turn, gradually whittling down the list of good runs, then
         * finally convert the remainder into Spans.
         */
        std::list<PrimaryRun> goodRuns;
 
        for (int m = 0; m < otherYRange; ++m) {
            auto mRange = std::equal_range(yRange.first, yRange.second, m, ComparePrimaryRunM());
            if ((mRange.first == mRange.second)) {
                // If a particular m is missing, we known that this y contains
                // no good runs; this is equivalent to Kim et al. step 3.2.
                goodRuns.clear();
            } else {
                // Consolidate all primary runs at this m so that they don't overlap.
                std::list<PrimaryRun> candidateRuns;
                int startX = mRange.first->xmin;
                int endX = mRange.first->xmax;
                for (auto run = mRange.first + 1; run != mRange.second; ++run) {
                    if (run->xmin > endX) {
                        // Start of a new run
                        candidateRuns.push_back(PrimaryRun{m, y, startX, endX});
                        startX = run->xmin;
                        endX = run->xmax;
                    } else {
                        // Continuation of an existing run
                        endX = run->xmax;
                    }
                }
                candidateRuns.push_back(PrimaryRun{m, y, startX, endX});
 
                // Otherwise, calculate the intersection of candidate runs at
                // this m with good runs from all previous m.
                if (m == 0) {
                    // For m = 0 we have nothing to compare to; all runs are accepted
                    std::swap(goodRuns, candidateRuns);
                } else {
                    std::list<PrimaryRun> newlist;
                    for (auto& good : goodRuns) {
                        for (auto& cand : candidateRuns) {
                            int start = std::max(good.xmin, cand.xmin);
                            int end = std::min(good.xmax, cand.xmax);
                            if (end >= start) {
                                newlist.push_back(PrimaryRun({m, y, start, end}));
                            }
                        }
                    }
                    std::swap(newlist, goodRuns);
                }
            }
        }
        for (auto& run : goodRuns) {
            tempVec.emplace_back(run.y, run.xmin, run.xmax);
        }
    }
    return std::make_shared<SpanSet>(std::move(tempVec));
}

findEdgePixels()

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::findEdgePixels

(

)

const

Select pixels within the SpanSet which touch its edge.

Definition at line 411 of file SpanSet.cc.

                                                     {
    image::Mask<image::MaskPixel> tempMask(getBBox());
    setMask(tempMask, static_cast<image::MaskPixel>(1));
    auto erodedSpanSet = eroded(1, Stencil::CIRCLE);
    erodedSpanSet->clearMask(tempMask, static_cast<image::MaskPixel>(1));
    return SpanSet::fromMask(tempMask);
}

flatten() [1/2]

template<typename Pixel , int inN, int inC>

ndarray::Array< typename std::remove_const< Pixel >::type, inN - 1, inN - 1 > lsst::afw::geom::SpanSet::flatten ( ndarray::Array< Pixel, inN, inC > const & input, lsst::geom::Point2I const & xy0 = lsst::geom::Point2I() ) const

inline

Reduce the pixel dimensionality from 2 to 1 of an array at points given by SpanSet.

Take values from an array at points defined by SpanSet and use them to populate a new array where the x,y coordinates of the SpanSet have been flattened to one dimension. First two dimensions of the input array must be the h,w which correspond to the SpanSet coordinates. Any number of remaining dimensions is permissible.

Template Parameters

Pixel	The datatype for the ndarray
inN	The number of dimensions in the array object
inC	Number of guaranteed row-major contiguous dimensions, starting from the end

Parameters

input	The ndarray from which the values will be taken
xy0	A point object with is used as the origin point for the SpanSet coordinate system

Definition at line 303 of file SpanSet.h.

                                                                  {
        // Populate a lower dimensional array with the values from input taken at the points of SpanSet
        auto outputShape = ndarray::concatenate(ndarray::makeVector(getArea()),
                                                input.getShape().template last<inN - 2>());
        ndarray::Array<typename std::remove_const<Pixel>::type, inN - 1, inN - 1> outputArray =
                ndarray::allocate(outputShape);
        outputArray.deep() = 0;
        flatten(outputArray, input, xy0);
        return outputArray;
    }

flatten() [2/2]

template<typename PixelIn , typename PixelOut , int inA, int outC, int inC>

void lsst::afw::geom::SpanSet::flatten ( ndarray::Array< PixelOut, inA - 1, outC > const & output, ndarray::Array< PixelIn, inA, inC > const & input, lsst::geom::Point2I const & xy0 = lsst::geom::Point2I() ) const

inline

Reduce the pixel dimensionality from 2 to 1 of an array at points given by SpanSet.

Take values from an array at points defined by SpanSet and use them to populate a new array where the x,y coordinates of the SpanSet have been flattened to one dimension. First two dimensions of the input array must be the h,w which correspond to the SpanSet coordinates. Any number of remaining dimensions is permissible.

Template Parameters

PixelOut	The data-type for the output ndarray
PixelIn	The data-type for the input ndarray
inA	The number of dimensions in the input array
outC	Number of guaranteed row-major contiguous dimensions in the output array, starting from the end
inC	Number of guaranteed row-major contiguous dimensions in the input array, starting from the end

Parameters

[out]	output	The 1d ndarray which will be populated with output parameters, will happen in place
[in]	input	The ndarray from which the values will be taken
[in]	xy0	A point object which is used as the origin point for the SpanSet coordinate system

Definition at line 336 of file SpanSet.h.

                                                                       {
        auto ndAssigner = [](lsst::geom::Point2I const &point,
                             typename details::FlatNdGetter<PixelOut, inA - 1, outC>::Reference out,
                             typename details::ImageNdGetter<PixelIn, inA, inC>::Reference in) { out = in; };
        // Populate array output with values from input at positions given by SpanSet
        applyFunctor(ndAssigner, ndarray::ndFlat(output), ndarray::ndImage(input, xy0));
    }

fromMask() [1/2]

template<typename T >

static std::shared_ptr< geom::SpanSet > lsst::afw::geom::SpanSet::fromMask ( image::Mask< T > const & mask, T bitmask )

inlinestatic

Create a SpanSet from a mask.

Create a SpanSet from a Mask at pixels with the specified bit pattern

Template Parameters

T	Pixel type of the Mask

Parameters

mask	mask to convert to a SpanSet
bitmask	bit pattern used to specify which pixel to include

Definition at line 701 of file SpanSet.h.

                                                                                    {
        return fromMask(mask, [bitmask](T const &bitPattern) { return bitPattern & bitmask; });
    }

fromMask() [2/2]

template<typename T , typename UnaryPredicate = details::AnyBitSetFunctor<T>>

static std::shared_ptr< geom::SpanSet > lsst::afw::geom::SpanSet::fromMask ( image::Mask< T > const & mask, UnaryPredicate comparator = details::AnyBitSetFunctor<T>() )

inlinestatic

Create a SpanSet from a mask.

Create a SpanSet from a class. The default behavior is to include any pixels which have any bits set. More complex selection/filtering of bit patterns can be done by supplying a comparator function.

Template Parameters

T	Pixel type of the Mask
F	Type of the functor

Parameters

mask	mask to convert to a SpanSet
comparator	Functor object to use in the decision to include pixel in SpanSet. Should return true when a given pixel in the mask should be part of the SpanSet, and false otherwise. The functor takes a single value taken from the mask at the pixel under consideration. Defaults to evaluating true if the mask has bits set, and false otherwise.

Definition at line 644 of file SpanSet.h.

                                                                                                {
        // Create a vector which will hold all the spans created from the mask
        std::vector<Span> tempVec;
        // Grab some variables that will be used in the loop, so that they do not need to be fetched
        // every iteration.
        auto const maskArray = mask.getArray();
        auto const minPoint = mask.getBBox().getMin();
        auto const dimensions = maskArray.getShape();
        auto const minY = minPoint.getY();
        auto const minX = minPoint.getX();
        auto const dimMinusOne = dimensions[1] - 1;
        auto const yDim = dimensions[0];
        auto const xDim = dimensions[1];
        auto arrIter = maskArray.begin();
        for (size_t y = 0; y < yDim; ++y) {
            auto yWithOffset = y + minY;
            bool inSpan = false;  // are we currently in a span of interest?
            std::size_t start;    // starting x value of span we're currently in
            for (size_t x = 0; x < xDim; ++x) {
                bool compareValue = comparator((*arrIter)[x]);
                if (inSpan) {
                    // If we were in a span but now the condition isn't satisfied, it means the Span stops
                    // at the previous pixel.
                    if (!compareValue) {
                        tempVec.push_back(Span(yWithOffset, start + minX, x - 1 + minX));
                        inSpan = false;
                    }
                } else if (compareValue) {
                    // If we weren't in a span but now the condition is satisfied, we start a new span.
                    inSpan = true;
                    start = x;
                }
            }
            // Since the x loop is over, if we're still in a span, this means the Span was not
            // closed out and added to the vector. The last pixel should be included in the Span
            // and the Span should be closed and added to the vector of spans.
            if (inSpan) {
                tempVec.push_back(Span(yWithOffset, start + minX, dimMinusOne + minX));
            }
            ++arrIter;
        }
 
        // construct a SpanSet from the spans determined above
        return std::make_shared<SpanSet>(std::move(tempVec), false);
    }

fromShape() [1/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::fromShape ( geom::ellipses::Ellipse const & ellipse )

static

Factory function for creating SpanSets from an ellipse object.

Parameters

ellipse

An ellipse defining the region to create a SpanSet from

Definition at line 715 of file SpanSet.cc.

                                                                        {
    ellipses::PixelRegion pr(ellipse);
    return std::make_shared<SpanSet>(pr.begin(), pr.end());
}

fromShape() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::fromShape ( int r, Stencil s = Stencil::CIRCLE, lsst::geom::Point2I offset = lsst::geom::Point2I() )

static

Factory function for creating SpanSets from a Stencil.

Parameters

r	radius of the stencil, the length is inclusive i.e. 3 ranges from -3 to 3
s	must be an enumeration of type geom::Stencil. Specifies the shape of the newly created SpanSet. May be CIRCLE, MANHATTAN, or BOX
offset	This function usually creates a SpanSet centered about zero. This parameter is a point2I object which specifies an offset from zero to apply when creating the SpanSet.

Definition at line 688 of file SpanSet.cc.

                                                                                  {
    // Create a SpanSet from a given Stencil
    std::vector<Span> tempVec;
    tempVec.reserve(2 * r + 1);
    switch (s) {
        case Stencil::CIRCLE:
            for (auto dy = -r; dy <= r; ++dy) {
                int dx = static_cast<int>(sqrt(r * r - dy * dy));
                tempVec.emplace_back(dy + offset.getY(), -dx + offset.getX(), dx + offset.getX());
            }
            break;
        case Stencil::MANHATTAN:
            for (auto dy = -r; dy <= r; ++dy) {
                int dx = r - abs(dy);
                tempVec.emplace_back(dy + offset.getY(), -dx + offset.getX(), dx + offset.getX());
            }
            break;
        case Stencil::BOX:
            for (auto dy = -r; dy <= r; ++dy) {
                int dx = r;
                tempVec.emplace_back(dy + offset.getY(), -dx + offset.getX(), dx + offset.getX());
            }
            break;
    }
    return std::make_shared<SpanSet>(std::move(tempVec), false);
}

front()

const_reference lsst::afw::geom::SpanSet::front ( ) const

inline

Definition at line 92 of file SpanSet.h.

{ return const_cast<geom::Span &>(_spanVector.front()); }

getArea()

std::size_t lsst::afw::geom::SpanSet::getArea

(

)

const

Return the number of pixels in the SpanSet.

Definition at line 283 of file SpanSet.cc.

{ return _area; }

getBBox()

lsst::geom::Box2I lsst::afw::geom::SpanSet::getBBox

(

)

const

Return a new integer box which is the minimum size to contain the pixels.

Definition at line 286 of file SpanSet.cc.

{ return _bbox; }

getPersistenceName()

std::string lsst::afw::geom::SpanSet::getPersistenceName ( ) const

overrideprivatevirtual

Return the unique name used to persist this object and look up its factory.

Must be less than ArchiveIndexSchema::MAX_NAME_LENGTH characters.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 1042 of file SpanSet.cc.

{ return getSpanSetPersistenceName(); }

getPythonModule()

std::string lsst::afw::geom::SpanSet::getPythonModule ( ) const

inlineoverrideprivatevirtual

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 724 of file SpanSet.h.

{ return "lsst.afw.geom"; }

intersect() [1/2]

template<typename T >

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::intersect	(	image::Mask< T > const &	other,
		T	bitmask ) const

Determine the common points between a SpanSet and a Mask with a given bit pattern.

Template Parameters

T	Pixel type of the Mask

Parameters

other	Mask with which to calculate intersection
bitmask	The bit value to consider when intersecting

Definition at line 967 of file SpanSet.cc.

                                                                                    {
    return maskIntersect<T, false>(*this, other, bitmask);
}

intersect() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::intersect

(

SpanSet const &

other

)

const

Determine the common points between two SpanSets, and create a new SpanSet.

Parameters

other

The other SpanSet with which to intersect with

Definition at line 720 of file SpanSet.cc.

                                                                    {
    // Check if the bounding boxes overlap, if not return null SpanSet
    if (!_bbox.overlaps(other.getBBox())) {
        return std::make_shared<SpanSet>();
    }
    // Handel intersecting a SpanSet with itself
    if (other == *this) {
        return std::make_shared<SpanSet>(this->_spanVector);
    }
    std::vector<Span> tempVec;
    auto otherIter = other.begin();
    for (auto const& spn : _spanVector) {
        while (otherIter != other.end() && otherIter->getY() <= spn.getY()) {
            if (spansOverlap(spn, *otherIter)) {
                auto newMin = std::max(spn.getMinX(), otherIter->getMinX());
                auto newMax = std::min(spn.getMaxX(), otherIter->getMaxX());
                auto newSpan = Span(spn.getY(), newMin, newMax);
                tempVec.push_back(newSpan);
            }
            ++otherIter;
        }
    }
    return std::make_shared<SpanSet>(std::move(tempVec));
}

intersectNot() [1/2]

template<typename T >

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::intersectNot	(	image::Mask< T > const &	other,
		T	bitmask ) const

Determine the common points between a SpanSet and the logical inverse of a Mask for a given bit pattern.

Parameters

other	Mask with which to calculate intersection
bitmask	The bit value to consider when intersecting

Template Parameters

T	Pixel type of the Mask

Definition at line 972 of file SpanSet.cc.

                                                                                       {
    return maskIntersect<T, true>(*this, other, bitmask);
}

intersectNot() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::intersectNot

(

SpanSet const &

other

)

const

Determine the common points between a SpanSet and the logical inverse of a second SpanSet and return them in a new SpanSet.

Parameters

other

The spanset which will be logically inverted when computing the intersection

Definition at line 745 of file SpanSet.cc.

                                                                       {
    // Check if the bounding boxes overlap, if not simply return a copy of this
    if (!getBBox().overlaps(other.getBBox())) {
        return std::make_shared<SpanSet>(this->begin(), this->end());
    }
    // Handle calling a SpanSet's intersectNot with itself as an argument
    if (other == *this) {
        return std::make_shared<SpanSet>();
    }
    /* This function must find all the areas in this and not in other. These SpanSets
     * may be overlapping with this less than other a1|    b1|   a2|    b2|,
     * with this greater than other b1|    a1|     b2|    a2|,
     * with this containing other a1|    b1|     b2|     a2|,
     * or with other containing this  b1|    a1|    a2|   b2|
     */
    std::vector<Span> tempVec;
    auto otherIter = other.begin();
    for (auto const& spn : _spanVector) {
        bool added = false;
        bool spanStarted = false;
        int spanBottom = 0;
        while (otherIter != other.end() && otherIter->getY() <= spn.getY()) {
            if (spansOverlap(spn, *otherIter)) {
                added = true;
                /* To handle one span containing the other, the spans will be added
                 * piecewise, and let the SpanSet constructor normalize spans which
                 * end up contiguous. In the case where this is contained in other,
                 * these statements will all be false, and nothing will be added,
                 * which is the expected behavior.
                 *
                 * Intersection with the logical not of another SpanSet requires that the Intersection
                 * be tested against the condition that multiple Spans may be present in the other
                 * SpanSet at the same Y coordinate. I.E. If one row in *this would contain two
                 * disconnected Spans in other, the result should be three new Spans.
                 */
                // Check if a span is in the process of being created
                if (!spanStarted) {
                    // If the minimum value of the Span in  *this is less than that of other, add a new Span
                    if (spn.getMinX() < otherIter->getMinX()) {
                        tempVec.emplace_back(spn.getY(), spn.getMinX(), otherIter->getMinX() - 1);
                    }
                    // Conversely if the maximum value of the Span in *this is greater than that of other,
                    // Start a new span, and record what the minimum value of that span should be. This is
                    // because SpanSets can be disconnected, and the function must check if there are any
                    // additional Spans which fall in the same row
                    if (spn.getMaxX() > otherIter->getMaxX()) {
                        spanStarted = true;
                        spanBottom = otherIter->getMaxX() + 1;
                    }
                } else {
                    // A span is in the process of being created and should be finished and added
                    tempVec.emplace_back(spn.getY(), spanBottom, std::min(spn.getMaxX(), otherIter->getMinX() - 1));
                    spanStarted = false;
                    // Check if the span in *this extends past that of the Span from other, if so
                    // begin a new Span
                    if (spn.getMaxX() > otherIter->getMaxX()) {
                        spanStarted = true;
                        spanBottom = otherIter->getMaxX() + 1;
                    }
                }
            }
            if (otherIter->getMaxX() > spn.getMaxX()) {
                break;
            }
            ++otherIter;
        }
        // Check if a span has been started but not finished, if that is the case that means there are
        // no further spans on this row to consider and the span should be closed and added
        if (spanStarted) {
            tempVec.emplace_back(spn.getY(), spanBottom, spn.getMaxX());
        }
        /* If added is still zero, that means it did not overlap any of the spans in other
         * and should be included in the new span
         */
        if (!added) {
            tempVec.emplace_back(spn);
        }
    }
    return std::make_shared<SpanSet>(std::move(tempVec));
}

isContiguous()

bool lsst::afw::geom::SpanSet::isContiguous

(

)

const

Defines if the SpanSet is simply contiguous.

If the pixels can be traversed in such a way that every pixel can be reached without going over a pixel not contained in the SpanSet this method will return true. If the SpanSet is disjoint aka the above is not true and there is more than one region, returns false.

Definition at line 373 of file SpanSet.cc.

                                 {
    auto labeledPair = _makeLabels();
    // Here we want to check if there is only one label. Since _makeLabels always increments
    // at the end of each loop, we need to compare against the number 2. I.e. if everything
    // gets labeled 1, the label counter will increment to 2, and the if statement will always
    // be false and _makeLabels will fall through to the end and return to here.
    return labeledPair.second <= 2;
}

isPersistable()

bool lsst::afw::geom::SpanSet::isPersistable ( ) const

inlineoverridevirtualnoexcept

Return true if this particular object can be persisted using afw::table::io.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 709 of file SpanSet.h.

{ return true; }

operator!=()

bool lsst::afw::geom::SpanSet::operator!=

(

SpanSet const &

other

)

const

Definition at line 683 of file SpanSet.cc.

                                                   {
    // Check the equivalence of this SpanSet with another
    return _spanVector != other._spanVector;
}

operator=() [1/2]

SpanSet & lsst::afw::geom::SpanSet::operator= ( SpanSet && other )

inline

Definition at line 169 of file SpanSet.h.

{ return *this = other; }

operator=() [2/2]

SpanSet & lsst::afw::geom::SpanSet::operator= ( SpanSet const & )

default

operator==()

bool lsst::afw::geom::SpanSet::operator==

(

SpanSet const &

other

)

const

Compute equality between two SpanSets.

Parameters

other

The SpanSet for which equality will be computed

Definition at line 678 of file SpanSet.cc.

                                                   {
    // Check the equivalence of this SpanSet with another
    return _spanVector == other._spanVector;
}

overlaps()

bool lsst::afw::geom::SpanSet::overlaps

(

SpanSet const &

other

)

const

Specifies if this SpanSet overlaps with another SpanSet.

Parameters

other

A SpanSet for which overlapping comparison will be made

Definition at line 454 of file SpanSet.cc.

                                                 {
    // Function to check if two SpanSets overlap
    for (auto const& otherSpan : other) {
        for (auto const& spn : _spanVector) {
            if (spansOverlap(otherSpan, spn)) {
                return true;
            }
        }
    }
    return false;
}

readFits() [1/3]

static std::shared_ptr< lsst::afw::geom::SpanSet > lsst::afw::table::io::PersistableFacade< lsst::afw::geom::SpanSet >::readFits ( fits::Fits & fitsfile )

inlinestaticinherited

Read an object from an already open FITS object.

Parameters

[in]

fitsfile

FITS object to read from, already positioned at the desired HDU.

Definition at line 183 of file Persistable.h.

readFits() [2/3]

static std::shared_ptr< lsst::afw::geom::SpanSet > lsst::afw::table::io::PersistableFacade< lsst::afw::geom::SpanSet >::readFits ( fits::MemFileManager & manager, int hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a FITS file in memory.

Parameters

[in]	manager	Manager for the memory to read from.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 205 of file Persistable.h.

readFits() [3/3]

static std::shared_ptr< lsst::afw::geom::SpanSet > lsst::afw::table::io::PersistableFacade< lsst::afw::geom::SpanSet >::readFits ( std::string const & fileName, int hdu = fits::DEFAULT_HDU )

inlinestaticinherited

Read an object from a regular FITS file.

Parameters

[in]	fileName	Name of the file to read.
[in]	hdu	HDU to read, where 0 is the primary. The special value of afw::fits::DEFAULT_HDU skips the primary HDU if it is empty.

Definition at line 194 of file Persistable.h.

setImage()

template<typename ImageT >

template void lsst::afw::geom::SpanSet::setImage< double >	(	image::Image< ImageT > &	image,
		ImageT	val,
		lsst::geom::Box2I const &	region = lsst::geom::Box2I(),
		bool	doClip = false ) const

Set the values of an Image at points defined by the SpanSet.

Template Parameters

ImageT

The pixel type of the Image to be set

Parameters

[out]	image	The Image in which pixels will be set
[in]	val	The value to set
[in]	region	A bounding box limiting the scope of the SpanSet, points defined in the SpanSet which fall outside this box will be ignored if the doClip parameter is set to true, defaults to the bounding box of the image
[in]	doClip	Limit the copy operation to pixels in the SpanSet that lie within the region parameter defaults to false

Definition at line 922 of file SpanSet.cc.

                                          {
    lsst::geom::Box2I bbox;
    if (region.isEmpty()) {
        bbox = image.getBBox();
    } else {
        bbox = region;
    }
    auto setterFunc = [](lsst::geom::Point2I const& point, ImageT& out, ImageT in) { out = in; };
    try {
        if (doClip) {
            auto tmpSpan = this->clippedTo(bbox);
            tmpSpan->applyFunctor(setterFunc, image, val);
        } else {
            applyFunctor(setterFunc, image, val);
        }
    } catch (pex::exceptions::OutOfRangeError const&) {
        throw LSST_EXCEPT(pex::exceptions::OutOfRangeError,
                          "Footprint Bounds Outside image, set doClip to true");
    }
}

setMask()

template<typename T >

void lsst::afw::geom::SpanSet::setMask	(	lsst::afw::image::Mask< T > &	target,
		T	bitmask ) const

Set a Mask at pixels defined by the SpanSet.

Template Parameters

T	data-type of a pixel in the Mask plane

Parameters

[in,out]	target	Mask in which values will be set
[in]	bitmask	The bit pattern to set in the mask

Definition at line 945 of file SpanSet.cc.

                                                           {
    // Use a lambda to set bits in a mask at the locations given by SpanSet
    auto targetArray = target.getArray();
    auto xy0 = target.getBBox().getMin();
    auto maskFunctor = [](lsst::geom::Point2I const& point,
                          typename details::ImageNdGetter<T, 2, 1>::Reference maskVal,
                          T bitmask) { maskVal |= bitmask; };
    applyFunctor(maskFunctor, ndarray::ndImage(targetArray, xy0), bitmask);
}

shiftedBy() [1/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::shiftedBy	(	int	x,
		int	y ) const

Return a new SpanSet shifted by specified amount.

Parameters

x	number of pixels to shift in x dimension
y	number of pixels to shift in y dimension

Definition at line 419 of file SpanSet.cc.

                                                            {
    // Function to create a new SpanSet which is a copy of this, shifted by x and y
    return makeShift(x, y);
}

shiftedBy() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::shiftedBy

(

lsst::geom::Extent2I const &

offset

)

const

Return a new SpanSet shifted by specified amount.

Parameters

offset

integer extent which specifies amount to offset in x and y

Definition at line 424 of file SpanSet.cc.

                                                                              {
    // Function to create a new SpanSet which is a copy of this, shifted by an extent object
    return makeShift(offset.getX(), offset.getY());
}

size()

size_type lsst::afw::geom::SpanSet::size ( ) const

inline

Definition at line 94 of file SpanSet.h.

{ return _spanVector.size(); }

split()

std::vector< std::shared_ptr< SpanSet > > lsst::afw::geom::SpanSet::split

(

)

const

Split a discontinuous SpanSet into multiple SpanSets which are contiguous.

Definition at line 382 of file SpanSet.cc.

                                                       {
    auto labeledPair = _makeLabels();
    auto labels = labeledPair.first;
    auto numberOfLabels = labeledPair.second;
    std::vector<std::shared_ptr<SpanSet>> subRegions;
    // As the number of labels is known, the number of SpanSets to be created is also known
    // make a vector of vectors to hold the Spans which will correspond to each SpanSet
    std::vector<std::vector<Span>> subSpanLists(numberOfLabels - 1);
 
    // if numberOfLabels is 1, that means a null SpanSet is being operated on,
    // and we should return like
    if (numberOfLabels == 1) {
        subRegions.push_back(std::make_shared<SpanSet>());
        return subRegions;
    }
    subRegions.reserve(numberOfLabels - 1);
 
    // loop over the current SpanSet's spans sorting each of the spans according to the label
    // that was assigned
    for (std::size_t i = 0; i < _spanVector.size(); ++i) {
        subSpanLists[labels[i] - 1].push_back(_spanVector[i]);
    }
    // Transform each of the vectors of Spans into a SpanSet
    for (std::size_t i = 0; i < numberOfLabels - 1; ++i) {
        subRegions.push_back(std::make_shared<SpanSet>(subSpanLists[i]));
    }
    return subRegions;
}

transformedBy() [1/3]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::transformedBy

(

lsst::geom::AffineTransform const &

t

)

const

Return a new SpanSet who's pixels are the product of applying the specified transformation.

Parameters

t	An affine transform object which will be used to map the pixels

Definition at line 845 of file SpanSet.cc.

                                                                                    {
    // Transform points in SpanSet by the AffineTransform
    return transformedBy(*makeTransform(t));
}

transformedBy() [2/3]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::transformedBy

(

lsst::geom::LinearTransform const &

t

)

const

Return a new SpanSet who's pixels are the product of applying the specified transformation.

Parameters

t	A linear transform object which will be used to map the pixels

Definition at line 840 of file SpanSet.cc.

                                                                                    {
    // Transform points in SpanSet by the LinearTransform
    return transformedBy(lsst::geom::AffineTransform(t));
}

transformedBy() [3/3]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::transformedBy

(

TransformPoint2ToPoint2 const &

t

)

const

Return a new SpanSet who's pixels are the product of applying the specified transformation.

Parameters

t	A 2-D transform which will be used to map the pixels

Definition at line 850 of file SpanSet.cc.

                                                                                    {
    // If the SpanSet is empty, its bounding box corners are not
    // meaningful and cannot be transformed.
    if (_spanVector.empty()) {
        return std::make_shared<SpanSet>();
    }
 
    // Transform points in SpanSet by Transform<Point2Endpoint, Point2Endpoint>
    // Transform the original bounding box
    lsst::geom::Box2D newBBoxD;
    std::vector<lsst::geom::Point2D> fromCorners;
    fromCorners.reserve(4);
    for (auto const& fc : _bbox.getCorners()) {
        fromCorners.emplace_back(lsst::geom::Point2D(fc));
    }
    auto toPoints = t.applyForward(fromCorners);
 
    // Check that this was a valid transformation.
    // Inverses should be good to floating point precision, this is just
    // a very rough check.
    auto fromToPoints = t.applyInverse(toPoints);
    for (int i = 0; i < 4; ++i) {
        if ((std::abs(fromToPoints[i].getX() - fromCorners[i].getX()) > 1.0) ||
            (std::abs(fromToPoints[i].getY() - fromCorners[i].getY()) > 1.0)) {
            return std::make_shared<SpanSet>();
        }
    }
 
    for (auto const& tc : toPoints) {
        newBBoxD.include(tc);
    }
 
    lsst::geom::Box2I newBBoxI(newBBoxD);
 
    std::vector<lsst::geom::Point2D> newBoxPoints;
    newBoxPoints.reserve(newBBoxI.getWidth());
    std::vector<Span> tempVec;
    for (int y = newBBoxI.getBeginY(); y < newBBoxI.getEndY(); ++y) {
        bool inSpan = false;  // Are we in a span?
        int start = -1;       // Start of span
 
        // vectorize one row at a time (vectorizing the whole bbox would further improve performance
        // but could lead to memory issues for very large bounding boxes)
        newBoxPoints.clear();
        for (int x = newBBoxI.getBeginX(); x < newBBoxI.getEndX(); ++x) {
            newBoxPoints.emplace_back(lsst::geom::Point2D(x, y));
        }
        auto oldBoxPoints = t.applyInverse(newBoxPoints);
        auto oldBoxPointIter = oldBoxPoints.cbegin();
        for (int x = newBBoxI.getBeginX(); x < newBBoxI.getEndX(); ++x, ++oldBoxPointIter) {
            auto p = *oldBoxPointIter;
            int const xSource = std::floor(0.5 + p.getX());
            int const ySource = std::floor(0.5 + p.getY());
 
            if (contains(lsst::geom::Point2I(xSource, ySource))) {
                if (!inSpan) {
                    inSpan = true;
                    start = x;
                }
            } else if (inSpan) {
                inSpan = false;
                tempVec.emplace_back(y, start, x - 1);
            }
        }
        if (inSpan) {
            tempVec.emplace_back(y, start, newBBoxI.getMaxX());
        }
    }
    return std::make_shared<SpanSet>(std::move(tempVec));
}

unflatten() [1/2]

template<typename Pixel , int inA, int inC>

ndarray::Array< typename std::remove_const< Pixel >::type, inA+1, inA+1 > lsst::afw::geom::SpanSet::unflatten ( ndarray::Array< Pixel, inA, inC > const & input ) const

inline

Expand an array by one spatial dimension at points given by SpanSet.

Take values from a lower dimensional array and insert them in an output array with one additional dimension at points defined by the SpanSet, offset by the lower left hand corner of the bounding box of the SpanSet. The first two dimensions of the output array will correspond to the y,x dimensions of the SpanSet

Template Parameters

Pixel	The data-type for the ndarray
inA	Number of dimension of the input array
inC	Number of guaranteed row-major contiguous dimensions, starting from the end

Parameters

input

The ndarray from which the values will be taken

Definition at line 360 of file SpanSet.h.

                                                              {
        // Create a higher dimensional array the size of the bounding box and extra dimensions of input.
        // Populate values from input, placed at locations corresponding to SpanSet, offset by the
        // lower corner of the bounding box
        auto existingShape = input.getShape();
        typename decltype(existingShape)::Element height = _bbox.getHeight();
        typename decltype(existingShape)::Element width = _bbox.getWidth();
        auto outputShape = ndarray::concatenate(ndarray::makeVector(height, width),
                                                input.getShape().template last<inA - 1>());
        ndarray::Array<typename std::remove_const<Pixel>::type, inA + 1, inA + 1> outputArray =
                ndarray::allocate(outputShape);
        outputArray.deep() = 0;
        unflatten(outputArray, input, lsst::geom::Point2I(_bbox.getMinX(), _bbox.getMinY()));
        return outputArray;
    }

unflatten() [2/2]

template<typename PixelIn , typename PixelOut , int inA, int outC, int inC>

void lsst::afw::geom::SpanSet::unflatten ( ndarray::Array< PixelOut, inA+1, outC > const & output, ndarray::Array< PixelIn, inA, inC > const & input, lsst::geom::Point2I const & xy0 = lsst::geom::Point2I() ) const

inline

Expand an array by one spatial dimension at points given by SpanSet.

Take values from a lower dimensional array and insert them in an output array with one additional dimension at points defined by the SpanSet, offset by the lower left hand corner of the bounding box of the SpanSet. The first two dimensions of the output array will correspond to the y,x dimensions of the SpanSet

Template Parameters

PixelOut	The datatype for the output ndarray
PixelIn	The datatype for the input ndarray
inA	Number of dimensions of the input ndarray
outC	Number of guaranteed row-major contiguous dimensions in the output array, starting from the end
inC	Number of guaranteed row-major contiguous dimensions in the input array, starting from the end

Parameters

[out]	output	The 1d ndarray which will be populated with output parameters, will happen in place
[in]	input	The ndarray from which the values will be taken
[in]	xy0	A point object with is used as the origin point for the SpanSet coordinate system

Definition at line 397 of file SpanSet.h.

                                                                         {
        // Populate 2D ndarray output with values from input, at locations defined by SpanSet, optionally
        // offset by xy0
        auto ndAssigner = [](lsst::geom::Point2I const &point,
                             typename details::ImageNdGetter<PixelOut, inA + 1, outC>::Reference out,
                             typename details::FlatNdGetter<PixelIn, inA, inC>::Reference in) { out = in; };
        applyFunctor(ndAssigner, ndarray::ndImage(output, xy0), ndarray::ndFlat(input));
    }

union_() [1/2]

template<typename T >

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::union_	(	image::Mask< T > const &	other,
		T	bitmask ) const

Determine the union between a SpanSet and a Mask for a given bit pattern.

Template Parameters

T	Pixel type of the Mask

Parameters

other	Mask with which to calculate intersection
bitmask	The bit value to consider when intersecting

Definition at line 977 of file SpanSet.cc.

                                                                                 {
    auto comparator = [bitmask](T pixelValue) { return (pixelValue & bitmask); };
    auto spanSetFromMask = fromMask(other, comparator);
    return union_(*spanSetFromMask);
}

union_() [2/2]

std::shared_ptr< SpanSet > lsst::afw::geom::SpanSet::union_

(

SpanSet const &

other

)

const

Create a new SpanSet that contains all points from two SpanSets.

Parameters

other

The SpanSet from which the union will be calculated

Definition at line 826 of file SpanSet.cc.

                                                                 {
    /* Simply include Spans from both SpanSets in a new vector and let the SpanSet
     * constructor normalize any of the SpanSets which may be contiguous
     */
    std::size_t combineSize = size() + other.size();
    std::vector<Span> tempVec;
    tempVec.reserve(combineSize);
    // Copy this
    tempVec.insert(tempVec.end(), _spanVector.begin(), _spanVector.end());
    // Copy other
    tempVec.insert(tempVec.end(), other.begin(), other.end());
    return std::make_shared<SpanSet>(std::move(tempVec));
}

write()

void lsst::afw::geom::SpanSet::write ( OutputArchiveHandle & handle ) const

overrideprivatevirtual

Write the object to one or more catalogs.

The handle object passed to this function provides an interface for adding new catalogs and adding nested objects to the same archive (while checking for duplicates). See OutputArchiveHandle for more information.

Reimplemented from lsst::afw::table::io::Persistable.

Definition at line 1044 of file SpanSet.cc.

                                                     {
    auto const& keys = SpanSetPersistenceHelper::get();
    auto spanCat = handle.makeCatalog(keys.spanSetSchema);
    spanCat.reserve(size());
    for (auto const& val : *this) {
        auto record = spanCat.addNew();
        record->set(keys.spanY, val.getY());
        record->set(keys.spanX0, val.getX0());
        record->set(keys.spanX1, val.getX1());
    }
    handle.saveCatalog(spanCat);
}

writeFits() [1/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::Fits & fitsfile ) const

inherited

Write the object to an already-open FITS object.

Parameters

[in]

fitsfile

Open FITS object to write to.

Definition at line 18 of file Persistable.cc.

                                                    {
    OutputArchive archive;
    archive.put(this);
    archive.writeFits(fitsfile);
}

writeFits() [2/3]

void lsst::afw::table::io::Persistable::writeFits ( fits::MemFileManager & manager, std::string const & mode = "w" ) const

inherited

Write the object to a FITS image in memory.

Parameters

[in]	manager	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 29 of file Persistable.cc.

                                                                                    {
    fits::Fits fitsfile(manager, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

writeFits() [3/3]

void lsst::afw::table::io::Persistable::writeFits ( std::string const & fileName, std::string const & mode = "w" ) const

inherited

Write the object to a regular FITS file.

Parameters

[in]	fileName	Name of the file to write to.
[in]	mode	If "w", any existing file with the given name will be overwritten. If "a", new HDUs will be appended to an existing file.

Definition at line 24 of file Persistable.cc.

                                                                                  {
    fits::Fits fitsfile(fileName, mode, fits::Fits::AUTO_CLOSE | fits::Fits::AUTO_CHECK);
    writeFits(fitsfile);
}

Friends And Related Symbol Documentation

SpansSetFactory

friend class SpansSetFactory

friend

Definition at line 732 of file SpanSet.h.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/include/lsst/afw/geom/SpanSet.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/geom/SpanSet.cc