lsst::afw::math::detail::WarpAtOnePoint< DestImageT, SrcImageT > Class Template Reference

A functor that computes one warped pixel. More...

#include <WarpAtOnePoint.h>

Public Member Functions
	WarpAtOnePoint (SrcImageT const &srcImage, WarpingControl const &control, typename DestImageT::SinglePixel padValue)
bool	operator() (typename DestImageT::x_iterator &destXIter, lsst::geom::Point2D const &srcPos, double relativeArea, lsst::afw::image::detail::Image_tag)
	Compute one warped pixel, Image specialization.
bool	operator() (typename DestImageT::x_iterator &destXIter, lsst::geom::Point2D const &srcPos, double relativeArea, lsst::afw::image::detail::MaskedImage_tag)
	Compute one warped pixel, MaskedImage specialization.

Detailed Description

template<typename DestImageT, typename SrcImageT>
class lsst::afw::math::detail::WarpAtOnePoint< DestImageT, SrcImageT >

A functor that computes one warped pixel.

Definition at line 40 of file WarpAtOnePoint.h.

Constructor & Destructor Documentation

WarpAtOnePoint()

template<typename DestImageT , typename SrcImageT >

lsst::afw::math::detail::WarpAtOnePoint< DestImageT, SrcImageT >::WarpAtOnePoint ( SrcImageT const & srcImage, WarpingControl const & control, typename DestImageT::SinglePixel padValue )

inline

Definition at line 42 of file WarpAtOnePoint.h.

            : _srcImage(srcImage),
              _kernelPtr(control.getWarpingKernel()),
              _maskKernelPtr(control.getMaskWarpingKernel()),
              _hasMaskKernel(control.getMaskWarpingKernel()),
              _kernelCtr(_kernelPtr->getCtr()),
              _maskKernelCtr(_maskKernelPtr ? _maskKernelPtr->getCtr() : lsst::geom::Point2I(0, 0)),
              _growFullMask(control.getGrowFullMask()),
              _xList(_kernelPtr->getWidth()),
              _yList(_kernelPtr->getHeight()),
              _maskXList(_maskKernelPtr ? _maskKernelPtr->getWidth() : 0),
              _maskYList(_maskKernelPtr ? _maskKernelPtr->getHeight() : 0),
              _padValue(padValue),
              _srcGoodBBox(_kernelPtr->shrinkBBox(srcImage.getBBox(lsst::afw::image::LOCAL))){};

Member Function Documentation

operator()() [1/2]

template<typename DestImageT , typename SrcImageT >

bool lsst::afw::math::detail::WarpAtOnePoint< DestImageT, SrcImageT >::operator() ( typename DestImageT::x_iterator & destXIter, lsst::geom::Point2D const & srcPos, double relativeArea, lsst::afw::image::detail::Image_tag  )

inline

Compute one warped pixel, Image specialization.

The Image specialization ignores the mask warping kernel, even if present

Definition at line 63 of file WarpAtOnePoint.h.

                                                                      {
        // Compute associated source pixel index as integer and nonnegative fractional parts;
        // the latter is used to compute the remapping kernel.
        std::pair<int, double> srcIndFracX = _srcImage.positionToIndex(srcPos[0], lsst::afw::image::X);
        std::pair<int, double> srcIndFracY = _srcImage.positionToIndex(srcPos[1], lsst::afw::image::Y);
        if (srcIndFracX.second < 0) {
            ++srcIndFracX.second;
            --srcIndFracX.first;
        }
        if (srcIndFracY.second < 0) {
            ++srcIndFracY.second;
            --srcIndFracY.first;
        }
 
        if (_srcGoodBBox.contains(lsst::geom::Point2I(srcIndFracX.first, srcIndFracY.first))) {
            // Offset source pixel index from kernel center to kernel corner (0, 0)
            // so we can convolveAtAPoint the pixels that overlap between source and kernel
            int srcStartX = srcIndFracX.first - _kernelCtr[0];
            int srcStartY = srcIndFracY.first - _kernelCtr[1];
 
            // Compute warped pixel
            double kSum = _setFracIndex(srcIndFracX.second, srcIndFracY.second);
 
            typename SrcImageT::const_xy_locator srcLoc = _srcImage.xy_at(srcStartX, srcStartY);
 
            *destXIter = lsst::afw::math::convolveAtAPoint<DestImageT, SrcImageT>(srcLoc, _xList, _yList);
            *destXIter *= relativeArea / kSum;
            return true;
        } else {
            // Edge pixel
            *destXIter = _padValue;
            return false;
        }
    }

operator()() [2/2]

template<typename DestImageT , typename SrcImageT >

bool lsst::afw::math::detail::WarpAtOnePoint< DestImageT, SrcImageT >::operator() ( typename DestImageT::x_iterator & destXIter, lsst::geom::Point2D const & srcPos, double relativeArea, lsst::afw::image::detail::MaskedImage_tag  )

inline

Compute one warped pixel, MaskedImage specialization.

The MaskedImage specialization uses the mask warping kernel, if present, to compute the mask plane; otherwise it uses the normal kernel to compute the mask plane.

Definition at line 105 of file WarpAtOnePoint.h.

                                                                            {
        // Compute associated source pixel index as integer and nonnegative fractional parts;
        // the latter is used to compute the remapping kernel.
        std::pair<int, double> srcIndFracX = _srcImage.positionToIndex(srcPos[0], lsst::afw::image::X);
        std::pair<int, double> srcIndFracY = _srcImage.positionToIndex(srcPos[1], lsst::afw::image::Y);
        if (srcIndFracX.second < 0) {
            ++srcIndFracX.second;
            --srcIndFracX.first;
        }
        if (srcIndFracY.second < 0) {
            ++srcIndFracY.second;
            --srcIndFracY.first;
        }
 
        if (_srcGoodBBox.contains(lsst::geom::Point2I(srcIndFracX.first, srcIndFracY.first))) {
            // Offset source pixel index from kernel center to kernel corner (0, 0)
            // so we can convolveAtAPoint the pixels that overlap between source and kernel
            int srcStartX = srcIndFracX.first - _kernelCtr[0];
            int srcStartY = srcIndFracY.first - _kernelCtr[1];
 
            // Compute warped pixel
            double kSum = _setFracIndex(srcIndFracX.second, srcIndFracY.second);
 
            typename SrcImageT::const_xy_locator srcLoc = _srcImage.xy_at(srcStartX, srcStartY);
 
            *destXIter = lsst::afw::math::convolveAtAPoint<DestImageT, SrcImageT>(srcLoc, _xList, _yList);
            *destXIter *= relativeArea / kSum;
 
            if (_hasMaskKernel) {
                // compute mask value based on the mask kernel (replacing the value computed above)
                int maskStartX = srcIndFracX.first - _maskKernelCtr[0];
                int maskStartY = srcIndFracY.first - _maskKernelCtr[1];
 
                typename SrcImageT::Mask::const_xy_locator srcMaskLoc =
                        _srcImage.getMask()->xy_at(maskStartX, maskStartY);
 
                using k_iter = typename std::vector<lsst::afw::math::Kernel::Pixel>::const_iterator;
 
                typename DestImageT::Mask::SinglePixel destMaskValue = 0;
                for (double kValY : _maskYList) {
                    typename DestImageT::Mask::SinglePixel destMaskValueY = 0;
                    for (k_iter kernelXIter = _maskXList.begin(), xEnd = _maskXList.end();
                         kernelXIter != xEnd; ++kernelXIter, ++srcMaskLoc.x()) {
                        typename lsst::afw::math::Kernel::Pixel const kValX = *kernelXIter;
                        if (kValX != 0) {
                            destMaskValueY |= *srcMaskLoc;
                        }
                    }
 
                    if (kValY != 0) {
                        destMaskValue |= destMaskValueY;
                    }
 
                    srcMaskLoc += lsst::afw::image::detail::difference_type(-_maskXList.size(), 1);
                }
 
                destXIter.mask() = (destXIter.mask() & _growFullMask) | destMaskValue;
            }
            return true;
        } else {
            // Edge pixel
            *destXIter = _padValue;
            return false;
        }
    }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/afw/g5a732f18d5+66d966b544/include/lsst/afw/math/detail/WarpAtOnePoint.h