lsst::afw::math::detail::KernelImagesForRegion Class Reference

A collection of Kernel images for special locations on a rectangular region of an image. More...

#include <Convolve.h>

Public Types
enum	Location { BOTTOM_LEFT , BOTTOM_RIGHT , TOP_LEFT , TOP_RIGHT }
	locations of various points in the region More...
using	KernelConstPtr = std::shared_ptr<const lsst::afw::math::Kernel>
using	Image = lsst::afw::image::Image<lsst::afw::math::Kernel::Pixel>
using	ImagePtr = std::shared_ptr<Image>
using	ImageConstPtr = std::shared_ptr<const Image>

Public Member Functions
	KernelImagesForRegion (KernelConstPtr kernelPtr, lsst::geom::Box2I const &bbox, lsst::geom::Point2I const &xy0, bool doNormalize)
	Construct a KernelImagesForRegion.
	KernelImagesForRegion (KernelConstPtr kernelPtr, lsst::geom::Box2I const &bbox, lsst::geom::Point2I const &xy0, bool doNormalize, ImagePtr bottomLeftImagePtr, ImagePtr bottomRightImagePtr, ImagePtr topLeftImagePtr, ImagePtr topRightImagePtr)
	Construct a KernelImagesForRegion with some or all corner images.
lsst::geom::Box2I	getBBox () const
	Get the bounding box for the region.
lsst::geom::Point2I	getXY0 () const
	Get xy0 of the image.
bool	getDoNormalize () const
	Get the doNormalize parameter.
ImagePtr	getImage (Location location) const
	Return the image and sum at the specified location.
KernelConstPtr	getKernel () const
	Get the kernel (as a shared pointer to const)
lsst::geom::Point2I	getPixelIndex (Location location) const
	Compute pixel index of a given location, relative to the parent image (thus offset by bottom left corner of bounding box)
bool	computeNextRow (RowOfKernelImagesForRegion &regionRow) const
	Compute next row of subregions.

Static Public Member Functions
static int	getMinInterpolationSize ()
	Get the minInterpolationSize class constant.

Detailed Description

A collection of Kernel images for special locations on a rectangular region of an image.

See the Location enum for a list of those special locations.

Warning

The kernel images along the top and right edges are computed one row or column past the bounding box. This allows abutting KernelImagesForRegion to share corner and edge kernel images, which is useful when dividing a KernelImagesForRegion into subregions.

The bounding box for the region applies to the parent image.

This is a low-level helper class for recursive convolving with interpolation. Many of these objects may be created during a convolution, and many will share kernel images. It uses shared pointers to kernels and kernel images for increased speed and decreased memory usage (at the expense of safety). Note that null pointers are NOT acceptable for the constructors!

Also note that it uses lazy evaluation: images are computed when they are wanted.

Definition at line 172 of file Convolve.h.

Member Typedef Documentation

Image

using lsst::afw::math::detail::KernelImagesForRegion::Image = lsst::afw::image::Image<lsst::afw::math::Kernel::Pixel>

Definition at line 175 of file Convolve.h.

ImageConstPtr

using lsst::afw::math::detail::KernelImagesForRegion::ImageConstPtr = std::shared_ptr<const Image>

Definition at line 177 of file Convolve.h.

ImagePtr

using lsst::afw::math::detail::KernelImagesForRegion::ImagePtr = std::shared_ptr<Image>

Definition at line 176 of file Convolve.h.

KernelConstPtr

using lsst::afw::math::detail::KernelImagesForRegion::KernelConstPtr = std::shared_ptr<const lsst::afw::math::Kernel>

Definition at line 174 of file Convolve.h.

Member Enumeration Documentation

Location

enum lsst::afw::math::detail::KernelImagesForRegion::Location

locations of various points in the region

RIGHT and TOP are one column/row beyond the region's bounding box. Thus adjacent regions share corner images.

The posiitions are: BOTTOM_LEFT, BOTTOM_RIGHT, TOP_LEFT, TOP_RIGHT

These locations always refer to the center of a pixel. Thus if the region has an odd size along an axis (so that the span to the top and right, which are one beyond, is even), the middle pixel will be 1/2 pixel off from the true center along that axis (in an unspecified direction).

Enumerator
BOTTOM_LEFT
BOTTOM_RIGHT
TOP_LEFT
TOP_RIGHT

Definition at line 192 of file Convolve.h.

{ BOTTOM_LEFT, BOTTOM_RIGHT, TOP_LEFT, TOP_RIGHT };

Constructor & Destructor Documentation

KernelImagesForRegion() [1/2]

lsst::afw::math::detail::KernelImagesForRegion::KernelImagesForRegion	(	KernelConstPtr	kernelPtr,
		lsst::geom::Box2I const &	bbox,
		lsst::geom::Point2I const &	xy0,
		bool	doNormalize )

Construct a KernelImagesForRegion.

Parameters

kernelPtr	kernel
bbox	bounding box of region of an image for which we want to compute kernel images (inclusive and relative to parent image)
xy0	xy0 of image for which we want to compute kernel images
doNormalize	normalize the kernel images?

Exceptions

lsst::pex::exceptions::InvalidParameterError

if kernelPtr is null

Definition at line 45 of file KernelImagesForRegion.cc.

        : _kernelPtr(kernelPtr), _bbox(bbox), _xy0(xy0), _doNormalize(doNormalize), _imagePtrList(4) {
    if (!_kernelPtr) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "kernelPtr is null");
    }
    LOGL_DEBUG("TRACE5.lsst.afw.math.convolve.KernelImagesForRegion",
               "KernelImagesForRegion(bbox(minimum=(%d, %d), extent=(%d, %d)), xy0=(%d, %d), doNormalize=%d, "
               "images...)",
               _bbox.getMinX(), _bbox.getMinY(), _bbox.getWidth(), _bbox.getHeight(), _xy0[0], _xy0[1],
               _doNormalize);
}

KernelImagesForRegion() [2/2]

lsst::afw::math::detail::KernelImagesForRegion::KernelImagesForRegion	(	KernelConstPtr	kernelPtr,
		lsst::geom::Box2I const &	bbox,
		lsst::geom::Point2I const &	xy0,
		bool	doNormalize,
		ImagePtr	bottomLeftImagePtr,
		ImagePtr	bottomRightImagePtr,
		ImagePtr	topLeftImagePtr,
		ImagePtr	topRightImagePtr )

Construct a KernelImagesForRegion with some or all corner images.

Null corner image pointers are ignored.

Parameters

kernelPtr	kernel
bbox	bounding box of region of an image for which we want to compute kernel images (inclusive and relative to parent image)
xy0	xy0 of image
doNormalize	normalize the kernel images?
bottomLeftImagePtr	kernel image and sum at bottom left of region
bottomRightImagePtr	kernel image and sum at bottom right of region
topLeftImagePtr	kernel image and sum at top left of region
topRightImagePtr	kernel image and sum at top right of region

Exceptions

lsst::pex::exceptions::InvalidParameterError	if kernelPtr is null
lsst::pex::exceptions::InvalidParameterError	if an image has the wrong dimensions

Warning

: if any images are incorrect you will get a mess.

Definition at line 58 of file KernelImagesForRegion.cc.

        : _kernelPtr(kernelPtr), _bbox(bbox), _xy0(xy0), _doNormalize(doNormalize), _imagePtrList(4) {
    if (!_kernelPtr) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, "kernelPtr is null");
    }
    _insertImage(BOTTOM_LEFT, bottomLeftImagePtr);
    _insertImage(BOTTOM_RIGHT, bottomRightImagePtr);
    _insertImage(TOP_LEFT, topLeftImagePtr);
    _insertImage(TOP_RIGHT, topRightImagePtr);
    LOGL_DEBUG("TRACE5.lsst.afw.math.convolve.KernelImagesForRegion",
               "KernelImagesForRegion(bbox(minimum=(%d, %d), extent=(%d, %d)), xy0=(%d, %d), doNormalize=%d, "
               "images...)",
               _bbox.getMinX(), _bbox.getMinY(), _bbox.getWidth(), _bbox.getHeight(), _xy0[0], _xy0[1],
               _doNormalize);
}

Member Function Documentation

computeNextRow()

bool lsst::afw::math::detail::KernelImagesForRegion::computeNextRow

(

RowOfKernelImagesForRegion &

regionRow

)

const

Compute next row of subregions.

For the first row call with a new RowOfKernelImagesForRegion (with the desired number of columns and rows). Every subequent call updates the data in the RowOfKernelImagesForRegion.

Parameters

[in,out]

regionRow

RowOfKernelImagesForRegion object

Returns

true if a new row was computed, false if supplied RowOfKernelImagesForRegion is for the last row.

Definition at line 110 of file KernelImagesForRegion.cc.

                                                                                      {
    if (regionRow.isLastRow()) {
        return false;
    }
 
    bool hasData = regionRow.hasData();
    int startY;
    if (hasData) {
        startY = regionRow.front()->getBBox().getMaxY() + 1;
    } else {
        startY = this->_bbox.getMinY();
    }
 
    int yInd = regionRow.incrYInd();
    int remHeight = 1 + this->_bbox.getMaxY() - startY;
    int remYDiv = regionRow.getNY() - yInd;
    int height = _computeNextSubregionLength(remHeight, remYDiv);
 
    if (hasData) {
        // Move each region up one segment
        bool isFirst = true;
        for (auto & rgnIter : regionRow) {
            rgnIter->_moveUp(isFirst, height);
            isFirst = false;
        }
 
    } else {
        ImagePtr blImagePtr = getImage(BOTTOM_LEFT);
        ImagePtr brImagePtr;
        ImagePtr tlImagePtr;
        ImagePtr const trImageNullPtr;
 
        lsst::geom::Point2I blCorner = lsst::geom::Point2I(this->_bbox.getMinX(), startY);
 
        int remWidth = this->_bbox.getWidth();
        int remXDiv = regionRow.getNX();
        for (auto & rgnIter : regionRow) {
            int width = _computeNextSubregionLength(remWidth, remXDiv);
            --remXDiv;
            remWidth -= width;
 
            std::shared_ptr<KernelImagesForRegion> regionPtr(new KernelImagesForRegion(
                    _kernelPtr, lsst::geom::Box2I(blCorner, lsst::geom::Extent2I(width, height)), _xy0,
                    _doNormalize, blImagePtr, brImagePtr, tlImagePtr, trImageNullPtr));
            rgnIter = regionPtr;
 
            if (!tlImagePtr) {
                regionPtr->getImage(TOP_LEFT);
            }
 
            blCorner += lsst::geom::Extent2I(width, 0);
            blImagePtr = regionPtr->getImage(BOTTOM_RIGHT);
            tlImagePtr = regionPtr->getImage(TOP_RIGHT);
        }
    }
    return true;
}

getBBox()

lsst::geom::Box2I lsst::afw::math::detail::KernelImagesForRegion::getBBox ( ) const

inline

Get the bounding box for the region.

Definition at line 234 of file Convolve.h.

{ return _bbox; };

getDoNormalize()

bool lsst::afw::math::detail::KernelImagesForRegion::getDoNormalize ( ) const

inline

Get the doNormalize parameter.

Definition at line 242 of file Convolve.h.

{ return _doNormalize; };

getImage()

KernelImagesForRegion::ImagePtr lsst::afw::math::detail::KernelImagesForRegion::getImage

(

Location

location

)

const

Return the image and sum at the specified location.

If the image has not yet been computed, it is computed at this time.

Parameters

location

location of image

Definition at line 77 of file KernelImagesForRegion.cc.

                                                                                     {
    if (_imagePtrList[location]) {
        return _imagePtrList[location];
    }
 
    ImagePtr imagePtr(new Image(_kernelPtr->getDimensions()));
    _imagePtrList[location] = imagePtr;
    _computeImage(location);
    return imagePtr;
}

getKernel()

KernelConstPtr lsst::afw::math::detail::KernelImagesForRegion::getKernel ( ) const

inline

Get the kernel (as a shared pointer to const)

Definition at line 254 of file Convolve.h.

{ return _kernelPtr; };

getMinInterpolationSize()

static int lsst::afw::math::detail::KernelImagesForRegion::getMinInterpolationSize ( )

inlinestatic

Get the minInterpolationSize class constant.

Definition at line 278 of file Convolve.h.

{ return _MinInterpolationSize; };

getPixelIndex()

lsst::geom::Point2I lsst::afw::math::detail::KernelImagesForRegion::getPixelIndex

(

Location

location

)

const

Compute pixel index of a given location, relative to the parent image (thus offset by bottom left corner of bounding box)

Parameters

location

location for which to return pixel index

Definition at line 88 of file KernelImagesForRegion.cc.

                                                                            {
    switch (location) {
        case BOTTOM_LEFT:
            return _bbox.getMin();
            break;  // paranoia
        case BOTTOM_RIGHT:
            return lsst::geom::Point2I(_bbox.getMaxX() + 1, _bbox.getMinY());
            break;  // paranoia
        case TOP_LEFT:
            return lsst::geom::Point2I(_bbox.getMinX(), _bbox.getMaxY() + 1);
            break;  // paranoia
        case TOP_RIGHT:
            return lsst::geom::Point2I(_bbox.getMaxX() + 1, _bbox.getMaxY() + 1);
            break;  // paranoia
        default: {
            std::ostringstream os;
            os << "Bug: unhandled location = " << location;
            throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
        }
    }
}

getXY0()

lsst::geom::Point2I lsst::afw::math::detail::KernelImagesForRegion::getXY0 ( ) const

inline

Get xy0 of the image.

Definition at line 238 of file Convolve.h.

{ return _xy0; };

---

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/math/detail/Convolve.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+53520f316c/src/math/detail/KernelImagesForRegion.cc