lsst::meas::algorithms Namespace Reference

Namespaces
namespace	accumulator_mean_stack
namespace	astrometrySourceSelector
namespace	brightStarStamps
namespace	cloughTocher2DInterpolator
namespace	coaddBoundedField
namespace	coaddPsf
namespace	computeExPsf
namespace	convertRefcatManager
namespace	convertReferenceCatalog
namespace	detection
namespace	dynamicDetection
namespace	findCosmicRaysConfig
namespace	flaggedSourceSelector
namespace	gaussianPsfFactory
namespace	gp_interpolation
namespace	htmIndexer
namespace	indexerRegistry
namespace	installGaussianPsf
namespace	interp
namespace	loadReferenceObjects
namespace	makeCoaddApCorrMap
namespace	makePsfCandidates
namespace	maskStreaks
namespace	matcherSourceSelector
namespace	measureApCorr
namespace	noise_covariance
namespace	normalizedCalibrationFlux
namespace	objectSizeStarSelector
namespace	pcaPsfDeterminer
namespace	psfCandidate
namespace	psfDeterminer
namespace	psfSelectionFromMatchList
namespace	readFitsCatalogTask
namespace	readTextCatalogTask
namespace	reinterpolate_pixels
namespace	reserveSourcesTask
namespace	scaleVariance
namespace	setPrimaryFlags
namespace	simple_curve
namespace	skyObjects
namespace	sourceSelector
namespace	stamps
namespace	starSelector
namespace	subtractBackground
namespace	testUtils
namespace	treecorrUtils
namespace	utils
namespace	variance_plane
namespace	version

Classes
class	CloughTocher2DInterpolatorUtils
	This class contains static utility methods that are used by the CloughTocher2DInterpolatorTask and exists solely to provide a namespace. More...
class	CoaddBoundedField
struct	CoaddBoundedFieldElement
	Struct used to hold one Exposure's data in a CoaddBoundedField. More...
class	CoaddPsf
	CoaddPsf is the Psf derived to be used for non-PSF-matched Coadd images. More...
class	CoaddPsfControl
class	Defect
	Encapsulate information about a bad portion of a detector. More...
class	DoubleGaussianPsf
	Represent a Psf as a circularly symmetrical double Gaussian. More...
class	evalChi2Visitor
	A class to pass around to all our PsfCandidates to evaluate the PSF fit's X^2. More...
class	ExposurePatch
	A convenience container for the exposure, peak and footprint that will be measured. More...
class	ImagePsf
	An intermediate base class for Psfs that use an image representation. More...
class	ImagePsfTrampoline
	"Trampoline" for ImagePsf to let it be used as a base class in Python. More...
class	KernelPsf
	A Psf defined by a Kernel. More...
class	KernelPsfFactory
	A PersistableFactory for KernelPsf and its subclasses. More...
struct	KernelPsfPersistenceHelper
	A read-only singleton struct containing the schema and key used in persistence for KernelPsf. More...
class	MinimizeChi2
class	PcaPsf
	Represent a PSF as a linear combination of PCA (== Karhunen-Loeve) basis functions. More...
class	PsfCandidate
	Class stored in SpatialCells for spatial Psf fitting. More...
class	PsfImagePca
class	SingleGaussianPsf
	Represent a PSF as a circularly symmetrical Gaussian. More...
class	WarpedPsf
	A Psf class that maps an arbitrary Psf through a coordinate transformation. More...

Typedefs
typedef std::vector< Defect::Ptr >::const_iterator	DefectCIter

Functions
std::shared_ptr< afw::image::TransmissionCurve const >	makeCoaddTransmissionCurve (std::shared_ptr< afw::geom::SkyWcs const > coaddWcs, afw::table::ExposureCatalog const &inputSensors)
	Create a TransmissionCurve that represents the effective throughput on a coadd.
template<typename MaskedImageT >
std::vector< std::shared_ptr< afw::detection::Footprint > >	findCosmicRays (MaskedImageT &mimage, afw::detection::Psf const &psf, double const bkgd, daf::base::PropertySet const &ps, bool const keep)
	Find cosmic rays in an Image, and mask and remove them.
template<typename ExposureT >
std::shared_ptr< ExposurePatch< ExposureT > >	makeExposurePatch (std::shared_ptr< ExposureT const > exp, std::shared_ptr< afw::detection::Footprint const > foot, geom::Point2D const &center)
	Factory function for ExposurePatch.
template<typename ExposureT >
std::shared_ptr< ExposurePatch< ExposureT > >	makeExposurePatch (std::shared_ptr< ExposureT const > exp, afw::detection::Footprint const &standardFoot, geom::Point2D const &standardCenter, afw::geom::SkyWcs const &standardWcs)
template<typename MaskedImageT >
void	interpolateOverDefects (MaskedImageT &mimage, afw::detection::Psf const &, std::vector< Defect::Ptr > &_badList, double fallbackValue, bool useFallbackValueAtEdge)
	Process a set of known bad pixels in an image.
template<typename PixelT >
std::shared_ptr< PsfCandidate< PixelT > >	makePsfCandidate (std::shared_ptr< afw::table::SourceRecord > const &source, std::shared_ptr< afw::image::Exposure< PixelT > > image)
	Return a PsfCandidate of the right sort.
template<typename PixelT >
std::pair< std::shared_ptr< afw::math::LinearCombinationKernel >, std::vector< double > >	createKernelFromPsfCandidates (afw::math::SpatialCellSet const &psfCells, lsst::geom::Extent2I const &dims, lsst::geom::Point2I const &xy0, int const nEigenComponents, int const spatialOrder, int const ksize, int const nStarPerCell, bool const constantWeight, int const border)
	Return a Kernel pointer and a list of eigenvalues resulting from analysing the provided SpatialCellSet.
template<typename PixelT >
int	countPsfCandidates (afw::math::SpatialCellSet const &psfCells, int const nStarPerCell)
	Count the number of candidates in use.
template<typename PixelT >
std::pair< bool, double >	fitSpatialKernelFromPsfCandidates (afw::math::Kernel *kernel, afw::math::SpatialCellSet const &psfCells, int const nStarPerCell, double const tolerance, double const lambda)
	Fit spatial kernel using full-nonlinear optimization to estimate candidate amplitudes.
template<typename PixelT >
std::pair< bool, double >	fitSpatialKernelFromPsfCandidates (afw::math::Kernel *kernel, afw::math::SpatialCellSet const &psfCells, bool const doNonLinearFit, int const nStarPerCell, double const tolerance, double const lambda)
	Fit spatial kernel using approximate fluxes for candidates, and solving a linear system of equations.
template<typename ImageT >
double	subtractPsf (afw::detection::Psf const &psf, ImageT *data, double x, double y, double psfFlux=std::numeric_limits< double >::quiet_NaN())
template<typename Image >
std::pair< std::vector< double >, afw::math::KernelList >	fitKernelParamsToImage (afw::math::LinearCombinationKernel const &kernel, Image const &image, geom::Point2D const &pos)
	Fit a LinearCombinationKernel to an Image, allowing the coefficients of the components to vary.
template<typename Image >
std::pair< std::shared_ptr< afw::math::Kernel >, std::pair< double, double > >	fitKernelToImage (afw::math::LinearCombinationKernel const &kernel, Image const &image, geom::Point2D const &pos)
	Fit a LinearCombinationKernel to an Image, allowing the coefficients of the components to vary.
void	wrapCoaddTransmissionCurve (WrapperCollection &wrappers)
void	wrapSingleGaussianPsf (WrapperCollection &wrappers)
void	wrapKernelPsf (WrapperCollection &wrappers)
void	wrapDoubleGaussianPsf (WrapperCollection &wrappers)
void	wrapInterp (WrapperCollection &wrappers)
void	wrapPcaPsf (WrapperCollection &wrappers)
void	wrapWarpedPsf (WrapperCollection &wrappers)
void	wrapPsfCandidate (WrapperCollection &wrappers)
void	wrapImagePsf (WrapperCollection &wrappers)
void	wrapSpatialModelPsf (WrapperCollection &wrappers)
void	wrapCoaddPsf (WrapperCollection &wrappers)
void	wrapCoaddBoundedField (WrapperCollection &wrappers)
void	wrapCr (WrapperCollection &wrappers)
void	wrapCloughTocher2DInterpolatorUtils (WrapperCollection &wrappers)
	PYBIND11_MODULE (_algorithmsLib, mod)
geom::Box2I	getOverallBBox (std::vector< std::shared_ptr< afw::image::Image< double > > > const &imgVector)
void	setSpatialParameters (afw::math::Kernel *kernel, std::vector< double > const &coeffs)
	Fit a Kernel's spatial variability from a set of stars.
void	setSpatialParameters (afw::math::Kernel *kernel, Eigen::VectorXd const &vec)
	Fit a Kernel's spatial variability from a set of stars.
template<typename MaskedImageT >
double	subtractPsf (afw::detection::Psf const &psf, MaskedImageT *data, double x, double y, double psfFlux)
	Subtract a PSF from an image at a given position.

Detailed Description

lsst.meas.algorithms

Typedef Documentation

DefectCIter

typedef std::vector<Defect::Ptr>::const_iterator lsst::meas::algorithms::DefectCIter

Definition at line 49 of file Interp.cc.

Function Documentation

countPsfCandidates()

template<typename PixelT >

int lsst::meas::algorithms::countPsfCandidates	(	afw::math::SpatialCellSet const &	psfCells,
		int const	nStarPerCell = -1 )

Count the number of candidates in use.

Definition at line 337 of file SpatialModelPsf.cc.

                                                                                      {
    countVisitor<PixelT> counter;
    psfCells.visitCandidates(&counter, nStarPerCell);
 
    return counter.getN();
}

createKernelFromPsfCandidates()

template<typename PixelT >

std::pair< std::shared_ptr< afw::math::LinearCombinationKernel >, std::vector< double > > lsst::meas::algorithms::createKernelFromPsfCandidates	(	afw::math::SpatialCellSet const &	psfCells,
		lsst::geom::Extent2I const &	dims,
		lsst::geom::Point2I const &	xy0,
		int const	nEigenComponents,
		int const	spatialOrder,
		int const	ksize,
		int const	nStarPerCell,
		bool const	constantWeight,
		int const	border )

Return a Kernel pointer and a list of eigenvalues resulting from analysing the provided SpatialCellSet.

The Kernel is a LinearCombinationKernel of the first nEigenComponents eigenImages

N.b. This is templated over the Pixel type of the science image

Parameters

psfCells	A SpatialCellSet containing PsfCandidates
dims	Dimensions of image
xy0	Origin of image
nEigenComponents	number of eigen components to keep; <= 0 => infty
spatialOrder	Order of spatial variation (cf. afw::math::PolynomialFunction2)
ksize	Size of generated Kernel images
nStarPerCell	max no. of stars per cell; <= 0 => infty
constantWeight	should each star have equal weight in the fit?
border	Border size for background subtraction

Definition at line 193 of file SpatialModelPsf.cc.

          {
    typedef typename afw::image::Image<PixelT> ImageT;
    typedef typename afw::image::MaskedImage<PixelT> MaskedImageT;
 
    //
    // Set the sizes for PsfCandidates made from either Images or MaskedImages
    //
    // lsst::meas::algorithms::PsfCandidate<ImageT>::setWidth(ksize);
    // lsst::meas::algorithms::PsfCandidate<ImageT>::setHeight(ksize);
    // lsst::meas::algorithms::PsfCandidate<MaskedImageT>::setWidth(ksize);
    // lsst::meas::algorithms::PsfCandidate<MaskedImageT>::setHeight(ksize);
    lsst::meas::algorithms::PsfCandidate<PixelT>::setWidth(ksize);
    lsst::meas::algorithms::PsfCandidate<PixelT>::setHeight(ksize);
 
    PsfImagePca<MaskedImageT> imagePca(constantWeight, border);  // Here's the set of images we'll analyze
 
    {
        SetPcaImageVisitor<PixelT> importStarVisitor(&imagePca);
        bool const ignoreExceptions = true;
        psfCells.visitCandidates(&importStarVisitor, nStarPerCell, ignoreExceptions);
    }
 
    //
    // Do a PCA decomposition of those PSF candidates.
    //
    // We have "gappy" data;  in other words we don't want to include any pixels with INTRP set
    //
    int niter = 10;          // number of iterations of updateBadPixels
    double deltaLim = 10.0;  // acceptable value of delta, the max change due to updateBadPixels
    lsst::afw::image::MaskPixel const BAD = afw::image::Mask<>::getPlaneBitMask("BAD");
    lsst::afw::image::MaskPixel const CR = afw::image::Mask<>::getPlaneBitMask("CR");
    lsst::afw::image::MaskPixel const INTRP = afw::image::Mask<>::getPlaneBitMask("INTRP");
 
    for (int i = 0; i != niter; ++i) {
        int const ncomp =
                (i == 0) ? 0
                         : ((nEigenComponents == 0) ? imagePca.getEigenImages().size() : nEigenComponents);
        double delta = imagePca.updateBadPixels(BAD | CR | INTRP, ncomp);
        if (i > 0 && delta < deltaLim) {
            break;
        }
 
        imagePca.analyze();
    }
 
    std::vector<std::shared_ptr<MaskedImageT>> eigenImages = imagePca.getEigenImages();
    std::vector<double> eigenValues = imagePca.getEigenValues();
    int const nEigen = static_cast<int>(eigenValues.size());
 
    int const ncomp = (nEigenComponents <= 0 || nEigen < nEigenComponents) ? nEigen : nEigenComponents;
    //
    // Set the background level of the components to 0.0 to avoid coupling variable background
    // levels to the form of the Psf.  More precisely, we calculate the mean of an outer "annulus"
    // of width bkg_border
    //
    for (int k = 0; k != ncomp; ++k) {
        ImageT const& im = *eigenImages[k]->getImage();
 
        int bkg_border = 2;
        if (bkg_border > im.getWidth()) {
            bkg_border = im.getWidth() / 2;
        }
        if (bkg_border > im.getHeight()) {
            bkg_border = im.getHeight() / 2;
        }
 
        double sum = 0;
        // Bottom and Top borders
        for (int i = 0; i != bkg_border; ++i) {
            typename ImageT::const_x_iterator ptrB = im.row_begin(i),
                                              ptrT = im.row_begin(im.getHeight() - i - 1);
            for (int j = 0; j != im.getWidth(); ++j, ++ptrB, ++ptrT) {
                sum += *ptrB + *ptrT;
            }
        }
        for (int i = bkg_border; i < im.getHeight() - bkg_border; ++i) {
            // Left and Right borders
            typename ImageT::const_x_iterator ptrL = im.row_begin(i),
                                              ptrR = im.row_begin(i) + im.getWidth() - bkg_border;
            for (int j = 0; j != bkg_border; ++j, ++ptrL, ++ptrR) {
                sum += *ptrL + *ptrR;
            }
        }
        sum /= 2 * (bkg_border * im.getWidth() + bkg_border * (im.getHeight() - 2 * bkg_border));
 
        *eigenImages[k] -= sum;
    }
    //
    // Now build our LinearCombinationKernel; build the lists of basis functions
    // and spatial variation, then assemble the Kernel
    //
    afw::math::KernelList kernelList;
    std::vector<afw::math::Kernel::SpatialFunctionPtr> spatialFunctionList;
    geom::Box2D const range = geom::Box2D(geom::Point2D(xy0), geom::Extent2D(dims));
 
    for (int i = 0; i != ncomp; ++i) {
        {
            // Enforce unit sum for kernel by construction
            // Zeroth component has unit sum
            // Other components have zero sum by normalising and then subtracting the zeroth component
            ImageT& image = *eigenImages[i]->getImage();
            double sum = std::accumulate(image.begin(true), image.end(true), 0.0);
            if (i == 0) {
                image /= sum;
            } else {
                for (typename ImageT::fast_iterator ptr0 = eigenImages[0]->getImage()->begin(true),
                                                    ptr1 = image.begin(true), end = image.end(true);
                     ptr1 != end; ++ptr0, ++ptr1) {
                    *ptr1 = *ptr1 / sum - *ptr0;
                }
            }
        }
 
        kernelList.push_back(std::shared_ptr<afw::math::Kernel>(new afw::math::FixedKernel(
                afw::image::Image<afw::math::Kernel::Pixel>(*eigenImages[i]->getImage(), true))));
 
        afw::math::Kernel::SpatialFunctionPtr
        //            spatialFunction(new afw::math::PolynomialFunction2<double>(spatialOrder));
        spatialFunction(new afw::math::Chebyshev1Function2<double>(spatialOrder, range));
        spatialFunction->setParameter(0, 1.0);  // the constant term; all others are 0
        spatialFunctionList.push_back(spatialFunction);
    }
 
    std::shared_ptr<afw::math::LinearCombinationKernel> psf(
            new afw::math::LinearCombinationKernel(kernelList, spatialFunctionList));
 
    return std::make_pair(psf, eigenValues);
}

findCosmicRays()

template<typename MaskedImageT >

std::vector< std::shared_ptr< afw::detection::Footprint > > lsst::meas::algorithms::findCosmicRays	(	MaskedImageT &	mimage,
		afw::detection::Psf const &	psf,
		double const	bkgd,
		daf::base::PropertySet const &	ps,
		bool const	keep )

Find cosmic rays in an Image, and mask and remove them.

Returns

vector of CR's Footprints

In this loop, we look for strings of CRpixels on the same row and adjoining columns; each of these becomes a Span with a unique ID.

In this loop, we look for strings of CRpixels on the same row and adjoining columns; each of these becomes a Span with a unique ID.

Parameters

mimage	Image to search
psf	the Image's PSF
bkgd	unsubtracted background of frame, DN
ps	PropertySet directing the behavior
keep	if true, don't remove the CRs

Definition at line 315 of file CR.cc.

  {
    typedef typename MaskedImageT::Image ImageT;
    typedef typename ImageT::Pixel ImagePixel;
    typedef typename MaskedImageT::Mask::Pixel MaskPixel;
 
    // Parse the PropertySet
    double const minSigma = ps.getAsDouble("minSigma");       // min sigma over sky in pixel for CR candidate
    double const minDn = ps.getAsDouble("min_DN");            // min number of DN in an CRs
    double const cond3Fac = ps.getAsDouble("cond3_fac");      // fiddle factor for condition #3
    double const cond3Fac2 = ps.getAsDouble("cond3_fac2");    // 2nd fiddle factor for condition #3
    int const niteration = ps.getAsInt("niteration");         // Number of times to look for contaminated
                                                              // pixels near CRs
    int const nCrPixelMax = ps.getAsInt("nCrPixelMax");       // maximum number of contaminated pixels
                                                              /*
                                                               * thresholds for 3rd condition
                                                               *
                                                               * Realise PSF at center of image
                                                               */
    std::shared_ptr<afw::math::Kernel const> kernel = psf.getLocalKernel(psf.getAveragePosition());
    if (!kernel) {
        throw LSST_EXCEPT(pexExcept::NotFoundError, "Psf is unable to return a kernel");
    }
    afw::detection::Psf::Image psfImage =
            afw::detection::Psf::Image(geom::ExtentI(kernel->getWidth(), kernel->getHeight()));
    kernel->computeImage(psfImage, true);
 
    int const xc = kernel->getCtr().getX();  // center of PSF
    int const yc = kernel->getCtr().getY();
 
    double const I0 = psfImage(xc, yc);
    double const thresH =
            cond3Fac2 * (0.5 * (psfImage(xc - 1, yc) + psfImage(xc + 1, yc))) / I0;  // horizontal
    double const thresV = cond3Fac2 * (0.5 * (psfImage(xc, yc - 1) + psfImage(xc, yc + 1))) / I0;  // vertical
    double const thresD = cond3Fac2 *
                          (0.25 * (psfImage(xc - 1, yc - 1) + psfImage(xc + 1, yc + 1) +
                                   psfImage(xc - 1, yc + 1) + psfImage(xc + 1, yc - 1))) /
                          I0;                                                  // diag
                                                                               /*
                                                                                * Setup desired mask planes
                                                                                */
    MaskPixel const badBit = mimage.getMask()->getPlaneBitMask("BAD");         // Generic bad pixels
    MaskPixel const crBit = mimage.getMask()->getPlaneBitMask("CR");           // CR-contaminated pixels
    MaskPixel const interpBit = mimage.getMask()->getPlaneBitMask("INTRP");    // Interpolated pixels
    MaskPixel const saturBit = mimage.getMask()->getPlaneBitMask("SAT");       // Saturated pixels
    MaskPixel const nodataBit = mimage.getMask()->getPlaneBitMask("NO_DATA");  // Non data pixels
 
    MaskPixel const badMask = (badBit | interpBit | saturBit | nodataBit);  // naughty pixels
                                                                            /*
                                                                             * Go through the frame looking at each pixel (except the edge ones which we ignore)
                                                                             */
    int const ncol = mimage.getWidth();
    int const nrow = mimage.getHeight();
 
    std::vector<CRPixel<ImagePixel>> crpixels;  // storage for detected CR-contaminated pixels
    typedef typename std::vector<CRPixel<ImagePixel>>::iterator crpixel_iter;
    typedef typename std::vector<CRPixel<ImagePixel>>::reverse_iterator crpixel_riter;
 
    for (int j = 1; j < nrow - 1; ++j) {
        typename MaskedImageT::xy_locator loc = mimage.xy_at(1, j);  // locator for data
 
        for (int i = 1; i < ncol - 1; ++i, ++loc.x()) {
            ImagePixel corr = 0;
            if (!is_cr_pixel<MaskedImageT>(&corr, loc, minSigma, thresH, thresV, thresD, bkgd, cond3Fac)) {
                continue;
            }
            /*
             * condition #4
             */
            if (loc.mask() & badMask) {
                continue;
            }
            if ((loc.mask(-1, 1) | loc.mask(0, 1) | loc.mask(1, 1) | loc.mask(-1, 0) | loc.mask(1, 0) |
                 loc.mask(-1, -1) | loc.mask(0, -1) | loc.mask(1, -1)) &
                interpBit) {
                continue;
            }
            /*
             * OK, it's a CR
             *
             * replace CR-contaminated pixels with reasonable values as we go through
             * image, which increases the detection rate
             */
            crpixels.push_back(CRPixel<ImagePixel>(i + mimage.getX0(), j + mimage.getY0(), loc.image()));
            loc.image() = corr; /* just a preliminary estimate */
 
            if (static_cast<int>(crpixels.size()) > nCrPixelMax) {
                reinstateCrPixels(mimage.getImage().get(), crpixels);
 
                throw LSST_EXCEPT(pex::exceptions::LengthError,
                                  (boost::format("Too many CR pixels (max %d)") % nCrPixelMax).str());
            }
        }
    }
    /*
     * We've found them on a pixel-by-pixel basis, now merge those pixels
     * into cosmic rays
     */
    std::vector<int> aliases;                  // aliases for initially disjoint parts of CRs
    aliases.reserve(1 + crpixels.size() / 2);  // initial size of aliases
 
    std::vector<afw::detection::IdSpan::Ptr> spans;  // y:x0,x1 for objects
    spans.reserve(aliases.capacity());               // initial size of spans
 
    aliases.push_back(0);  // 0 --> 0
 
    int ncr = 0;  // number of detected cosmic rays
    if (!crpixels.empty()) {
        int id;                        // id number for a CR
        int x0 = -1, x1 = -1, y = -1;  // the beginning and end column, and row of this span in a CR
 
        // I am dummy
        CRPixel<ImagePixel> dummy(0, -1, 0, -1);
        crpixels.push_back(dummy);
        // printf("Created dummy CR: i %i, id %i, col %i, row %i, val %g\n", dummy.get_i(), dummy.id,
        // dummy.col, dummy.row, (double)dummy.val);
        for (crpixel_iter crp = crpixels.begin(); crp < crpixels.end() - 1; ++crp) {
            // printf("Looking at CR: i %i, id %i, col %i, row %i, val %g\n", crp->get_i(), crp->id, crp->col,
            // crp->row, (double)crp->val);
 
            if (crp->id < 0) {    // not already assigned
                crp->id = ++ncr;  // a new CR
                aliases.push_back(crp->id);
                y = crp->row;
                x0 = x1 = crp->col;
                // printf("  Assigned ID %i; looking at row %i, start col %i\n", crp->id, crp->row, crp->col);
            }
            id = crp->id;
            // printf("  Next CRpix has i=%i, id=%i, row %i, col %i\n", crp[1].get_i(), crp[1].id, crp[1].row,
            // crp[1].col);
 
            if (crp[1].row == crp[0].row && crp[1].col == crp[0].col + 1) {
                // printf("  Adjoining!  Set next CRpix id = %i; x1=%i\n", crp[1].id, x1);
                crp[1].id = id;
                ++x1;
            } else {
                assert(y >= 0 && x0 >= 0 && x1 >= 0);
                spans.push_back(afw::detection::IdSpan::Ptr(new afw::detection::IdSpan(id, y, x0, x1)));
                // printf("  Not adjoining; adding span id=%i, y=%i, x = [%i, %i]\n", id, y, x0, x1);
            }
        }
    }
 
    // At the end of this loop, all crpixel entries have been assigned an ID,
    // except for the "dummy" entry at the end of the array.
    if (crpixels.size() > 0) {
        for (crpixel_iter cp = crpixels.begin(); cp != crpixels.end() - 1; cp++) {
            assert(cp->id >= 0);
            assert(cp->col >= 0);
            assert(cp->row >= 0);
        }
        // dummy:
        assert(crpixels[crpixels.size() - 1].id == -1);
        assert(crpixels[crpixels.size() - 1].col == 0);
        assert(crpixels[crpixels.size() - 1].row == -1);
    }
 
    for (std::vector<afw::detection::IdSpan::Ptr>::iterator sp = spans.begin(), end = spans.end(); sp != end;
         sp++) {
        assert((*sp)->id >= 0);
        assert((*sp)->y >= 0);
        assert((*sp)->x0 >= 0);
        assert((*sp)->x1 >= (*sp)->x0);
        for (std::vector<afw::detection::IdSpan::Ptr>::iterator sp2 = sp + 1; sp2 != end; sp2++) {
            assert((*sp2)->y >= (*sp)->y);
            if ((*sp2)->y == (*sp)->y) {
                assert((*sp2)->x0 > (*sp)->x1);
            }
        }
    }
 
    /*
     * See if spans touch each other
     */
    for (std::vector<afw::detection::IdSpan::Ptr>::iterator sp = spans.begin(), end = spans.end(); sp != end;
         ++sp) {
        int const y = (*sp)->y;
        int const x0 = (*sp)->x0;
        int const x1 = (*sp)->x1;
 
        // this loop will probably run for only a few steps
        for (std::vector<afw::detection::IdSpan::Ptr>::iterator sp2 = sp + 1; sp2 != end; ++sp2) {
            if ((*sp2)->y == y) {
                // on this row (but not adjoining columns, since it would have been merged into this span);
                // keep looking.
                continue;
            } else if ((*sp2)->y != (y + 1)) {
                // sp2 is more than one row below; can't be connected.
                break;
            } else if ((*sp2)->x0 > (x1 + 1)) {
                // sp2 is more than one column away to the right; can't be connected
                break;
            } else if ((*sp2)->x1 >= (x0 - 1)) {
                // touches
                int r1 = afw::detection::resolve_alias(aliases, (*sp)->id);
                int r2 = afw::detection::resolve_alias(aliases, (*sp2)->id);
                aliases[r1] = r2;
            }
        }
    }
 
    /*
     * Resolve aliases; first alias chains, then the IDs in the spans
     */
    for (unsigned int i = 0; i != spans.size(); ++i) {
        spans[i]->id = afw::detection::resolve_alias(aliases, spans[i]->id);
    }
 
    /*
     * Sort spans by ID, so we can sweep through them once
     */
    if (spans.size() > 0) {
        std::sort(spans.begin(), spans.end(), afw::detection::IdSpanCompar());
    }
 
    /*
     * Build Footprints from spans
     */
    std::vector<std::shared_ptr<afw::detection::Footprint>> CRs;  // our cosmic rays
 
    if (spans.size() > 0) {
        int id = spans[0]->id;
        unsigned int i0 = 0;                                 // initial value of i
        for (unsigned int i = i0; i <= spans.size(); ++i) {  // <= size to catch the last object
            if (i == spans.size() || spans[i]->id != id) {
                std::shared_ptr<afw::detection::Footprint> cr(new afw::detection::Footprint());
 
                std::vector<afw::geom::Span> spanList;
                spanList.reserve(i - i0);
                for (; i0 < i; ++i0) {
                    spanList.push_back(afw::geom::Span(spans[i0]->y, spans[i0]->x0, spans[i0]->x1));
                }
                cr->setSpans(std::make_shared<afw::geom::SpanSet>(std::move(spanList)));
                CRs.push_back(cr);
            }
 
            if (i < spans.size()) {
                id = spans[i]->id;
            }
        }
    }
 
    reinstateCrPixels(mimage.getImage().get(), crpixels);
    /*
     * apply condition #1
     */
    CountsInCR<typename ImageT::Pixel> CountDN(bkgd);
    for (std::vector<std::shared_ptr<afw::detection::Footprint>>::iterator cr = CRs.begin(), end = CRs.end();
         cr != end; ++cr) {
        // find the sum of pixel values within the CR
        (*cr)->getSpans()->applyFunctor(CountDN, *mimage.getImage());
 
        LOGL_DEBUG("TRACE4.lsst.algorithms.CR", "CR at (%d, %d) has %g DN", (*cr)->getBBox().getMinX(),
                   (*cr)->getBBox().getMinY(), CountDN.getCounts());
        if (CountDN.getCounts() < minDn) { /* not bright enough */
            LOGL_DEBUG("TRACE5.lsst.algorithms.CR", "Erasing CR");
 
            cr = CRs.erase(cr);
            --cr;  // back up to previous CR (we're going to increment it)
            --end;
        }
        CountDN.reset();
    }
    ncr = CRs.size(); /* some may have been too faint */
                      /*
                       * We've found them all, time to kill them all
                       */
    bool const debias_values = true;
    bool grow = false;
    LOGL_DEBUG("TRACE2.lsst.algorithms.CR", "Removing initial list of CRs");
    removeCR(mimage, CRs, bkgd, crBit, saturBit, badMask, debias_values, grow);
#if 0  // Useful to see phase 2 in display; debugging only
    (void)setMaskFromFootprintList(mimage.getMask().get(), CRs,
                                   mimage.getMask()->getPlaneBitMask("DETECTED"));
#endif
    /*
     * Now that we've removed them, go through image again, examining area around
     * each CR for extra bad pixels. Note that we set cond3Fac = 0 for this pass
     *
     * We iterate niteration times;  niter==1 was sufficient for SDSS data, but megacam
     * CCDs are different -- who knows for other devices?
     */
    bool too_many_crs = false;  // we've seen too many CR pixels
    int nextra = 0;             // number of pixels added to list of CRs
    for (int i = 0; i != niteration && !too_many_crs; ++i) {
        LOGL_DEBUG("TRACE1.lsst.algorithms.CR", "Starting iteration %d", i);
        for (std::vector<std::shared_ptr<afw::detection::Footprint>>::iterator fiter = CRs.begin();
             fiter != CRs.end(); fiter++) {
            std::shared_ptr<afw::detection::Footprint> cr = *fiter;
            /*
             * Are all those `CR' pixels interpolated?  If so, don't grow it
             */
            {
                // this work should be taken on in DM-9538
                // std::shared_ptr<afw::detection::Footprint> om = footprintAndMask(cr, mimage.getMask(),
                // interpBit);
                // Placeholder until DM-9538 then remove empty footprint
                auto om = std::make_shared<afw::detection::Footprint>();
                int const npix = (om) ? om->getArea() : 0;
 
                if (static_cast<std::size_t>(npix) == cr->getArea()) {
                    continue;
                }
            }
            /*
             * No; some of the suspect pixels aren't interpolated
             */
            afw::detection::Footprint extra;  // extra pixels added to cr
            for (auto siter = cr->getSpans()->begin(); siter != cr->getSpans()->end(); siter++) {
                auto const span = siter;
 
                /*
                 * Check the lines above and below the span.  We're going to check a 3x3 region around
                 * the pixels, so we need a buffer around the edge.  We check the pixels just to the
                 * left/right of the span, so the buffer needs to be 2 pixels (not just 1) in the
                 * column direction, but only 1 in the row direction.
                 */
                int const y = span->getY() - mimage.getY0();
                if (y < 2 || y >= nrow - 2) {
                    continue;
                }
                int x0 = span->getX0() - mimage.getX0();
                int x1 = span->getX1() - mimage.getX0();
                x0 = (x0 < 2) ? 2 : (x0 > ncol - 3) ? ncol - 3 : x0;
                x1 = (x1 < 2) ? 2 : (x1 > ncol - 3) ? ncol - 3 : x1;
 
                checkSpanForCRs(&extra, crpixels, y - 1, x0, x1, mimage, minSigma / 2, thresH, thresV, thresD,
                                bkgd, 0, keep);
                checkSpanForCRs(&extra, crpixels, y, x0, x1, mimage, minSigma / 2, thresH, thresV, thresD,
                                bkgd, 0, keep);
                checkSpanForCRs(&extra, crpixels, y + 1, x0, x1, mimage, minSigma / 2, thresH, thresV, thresD,
                                bkgd, 0, keep);
            }
 
            if (extra.getSpans()->size() > 0) {  // we added some pixels
                if (nextra + static_cast<int>(crpixels.size()) > nCrPixelMax) {
                    too_many_crs = true;
                    break;
                }
 
                nextra += extra.getArea();
 
                std::vector<afw::geom::Span> tmpSpanList(cr->getSpans()->begin(), cr->getSpans()->end());
                for (auto const &spn : (*extra.getSpans())) {
                    tmpSpanList.push_back(spn);
                }
                cr->setSpans(std::make_shared<afw::geom::SpanSet>(std::move(tmpSpanList)));
            }
        }
 
        if (nextra == 0) {
            break;
        }
    }
    /*
     * mark those pixels as CRs
     */
    if (!too_many_crs) {
        for (auto const &foot : CRs) {
            foot->getSpans()->setMask(*mimage.getMask().get(), crBit);
        }
    }
    /*
     * Maybe reinstate initial values; n.b. the same pixel may appear twice, so we want the
     * first value stored (hence the uses of rbegin/rend)
     *
     * We have to do this if we decide _not_ to remove certain CRs,
     * for example those which lie next to saturated pixels
     */
    if (keep || too_many_crs) {
        if (crpixels.size() > 0) {
            int const imageX0 = mimage.getX0();
            int const imageY0 = mimage.getY0();
 
            std::sort(crpixels.begin(), crpixels.end());  // sort into birth order
 
            crpixel_riter rend = crpixels.rend();
            for (crpixel_riter crp = crpixels.rbegin(); crp != rend; ++crp) {
                if (crp->row == -1)
                    // dummy; skip it.
                    continue;
                mimage.at(crp->col - imageX0, crp->row - imageY0).image() = crp->val;
            }
        }
    } else {
        if (true || nextra > 0) {
            grow = true;
            LOGL_DEBUG("TRACE2.lsst.algorithms.CR", "Removing final list of CRs, grow = %d", grow);
            removeCR(mimage, CRs, bkgd, crBit, saturBit, badMask, debias_values, grow);
        }
        /*
         * we interpolated over all CR pixels, so set the interp bits too
         */
        for (auto const &foot : CRs) {
            foot->getSpans()->setMask(*mimage.getMask().get(), static_cast<MaskPixel>(crBit | interpBit));
        }
    }
 
    if (too_many_crs) {  // we've cleaned up, so we can throw the exception
        throw LSST_EXCEPT(pex::exceptions::LengthError,
                          (boost::format("Too many CR pixels (max %d)") % nCrPixelMax).str());
    }
 
    return CRs;
}

fitKernelParamsToImage()

template<typename Image >

std::pair< std::vector< double >, afw::math::KernelList > lsst::meas::algorithms::fitKernelParamsToImage	(	afw::math::LinearCombinationKernel const &	kernel,
		Image const &	image,
		geom::Point2D const &	pos )

Fit a LinearCombinationKernel to an Image, allowing the coefficients of the components to vary.

Returns

std::pair(coefficients, std::pair(kernels, center amplitude))

Parameters

kernel	the Kernel to fit
image	the image to be fit
pos	the position of the object

Definition at line 1037 of file SpatialModelPsf.cc.

          {
    typedef afw::image::Image<afw::math::Kernel::Pixel> KernelT;
 
    afw::math::KernelList kernels = kernel.getKernelList();  // the Kernels that kernel adds together
    int const nKernel = kernels.size();
 
    if (nKernel == 0) {
        throw LSST_EXCEPT(lsst::pex::exceptions::LengthError, "Your kernel must have at least one component");
    }
 
    /*
     * Go through all the kernels, get a copy centered at the desired sub-pixel position, and then
     * extract a subImage from the parent image at the same place
     */
    std::vector<std::shared_ptr<KernelT>> kernelImages = offsetKernel<KernelT>(kernel, pos[0], pos[1]);
    geom::BoxI bbox(kernelImages[0]->getBBox());
    Image const& subImage(Image(image, bbox, afw::image::PARENT, false));  // shallow copy
 
    /*
     * Solve the linear problem  subImage = sum x_i K_i + epsilon; we solve this for x_i by constructing the
     * normal equations, A x = b
     */
    Eigen::MatrixXd A(nKernel, nKernel);
    Eigen::VectorXd b(nKernel);
 
    for (int i = 0; i != nKernel; ++i) {
        b(i) = afw::image::innerProduct(*kernelImages[i], *subImage.getImage());
 
        for (int j = i; j != nKernel; ++j) {
            A(i, j) = A(j, i) = afw::image::innerProduct(*kernelImages[i], *kernelImages[j]);
        }
    }
    Eigen::VectorXd x(nKernel);
 
    if (nKernel == 1) {
        x(0) = b(0) / A(0, 0);
    } else {
        x = A.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b);
    }
 
    // the XY0() point of the shifted Kernel basis functions
    geom::Point2I const xy0 = kernelImages[0]->getXY0();
 
    afw::math::KernelList newKernels(nKernel);
    std::vector<double> params(nKernel);
    for (int i = 0; i != nKernel; ++i) {
        std::shared_ptr<afw::math::Kernel> newKernel(new afw::math::FixedKernel(*kernelImages[i]));
        newKernel->setCtr(xy0 + newKernel->getDimensions() / 2);
 
        params[i] = x[i];
        newKernels[i] = newKernel;
    }
 
    return std::make_pair(params, newKernels);
}

fitKernelToImage()

template<typename Image >

std::pair< std::shared_ptr< afw::math::Kernel >, std::pair< double, double > > lsst::meas::algorithms::fitKernelToImage	(	afw::math::LinearCombinationKernel const &	kernel,
		Image const &	image,
		geom::Point2D const &	pos )

Fit a LinearCombinationKernel to an Image, allowing the coefficients of the components to vary.

Returns

std::pair(best-fit kernel, std::pair(amp, chi^2))

Parameters

kernel	the Kernel to fit
image	the image to be fit
pos	the position of the object

Definition at line 1104 of file SpatialModelPsf.cc.

          {
    std::pair<std::vector<double>, afw::math::KernelList> const fit =
            fitKernelParamsToImage(kernel, image, pos);
    std::vector<double> params = fit.first;
    afw::math::KernelList kernels = fit.second;
    int const nKernel = params.size();
    assert(kernels.size() == static_cast<unsigned int>(nKernel));
 
    double amp = 0.0;
    for (int i = 0; i != nKernel; ++i) {
        std::shared_ptr<afw::math::Kernel> base = kernels[i];
        std::shared_ptr<afw::math::FixedKernel> k = std::static_pointer_cast<afw::math::FixedKernel>(base);
        amp += params[i] * k->getSum();
    }
 
    std::shared_ptr<afw::math::Kernel> outputKernel(new afw::math::LinearCombinationKernel(kernels, params));
    double chisq = 0.0;
    outputKernel->setCtr(kernels[0]->getCtr());
 
    return std::make_pair(outputKernel, std::make_pair(amp, chisq));
}

fitSpatialKernelFromPsfCandidates() [1/2]

template<typename PixelT >

std::pair< bool, double > lsst::meas::algorithms::fitSpatialKernelFromPsfCandidates	(	afw::math::Kernel *	kernel,
		afw::math::SpatialCellSet const &	psfCells,
		bool const	doNonLinearFit,
		int const	nStarPerCell = -1,
		double const	tolerance = 1e-5,
		double const	lambda = 0.0 )

Fit spatial kernel using approximate fluxes for candidates, and solving a linear system of equations.

Parameters

kernel	the Kernel to fit
psfCells	A SpatialCellSet containing PsfCandidates
doNonLinearFit	Use the full-up nonlinear fitter
nStarPerCell	max no. of stars per cell; <= 0 => infty
tolerance	Tolerance; how close chi^2 should be to true minimum
lambda	floor for variance is lambda*data

Definition at line 876 of file SpatialModelPsf.cc.

          {
    if (doNonLinearFit) {
        return fitSpatialKernelFromPsfCandidates<PixelT>(kernel, psfCells, nStarPerCell, tolerance);
    }
 
    double const tau = 0;  // softening for errors
 
    afw::math::LinearCombinationKernel const* lcKernel =
            dynamic_cast<afw::math::LinearCombinationKernel const*>(kernel);
    if (!lcKernel) {
        throw LSST_EXCEPT(
                lsst::pex::exceptions::LogicError,
                "Failed to cast Kernel to LinearCombinationKernel while building spatial PSF model");
    }
#if 1
    //
    // Set the initial amplitudes of all our candidates
    //
    setAmplitudeVisitor<PixelT> setAmplitude;
    psfCells.visitAllCandidates(&setAmplitude, true);
#endif
    //
    // visitor that fills out the A and b matrices (we'll solve A x = b for the coeffs, x)
    //
    FillABVisitor<PixelT> getAB(*lcKernel, tau);
    //
    // Actually visit all our candidates
    //
    psfCells.visitCandidates(&getAB, nStarPerCell, true);
    //
    // Extract A and b, and solve Ax = b
    //
    Eigen::MatrixXd const& A = getAB.getA();
    Eigen::VectorXd const& b = getAB.getB();
    Eigen::VectorXd x0(b.size());  // Solution to matrix problem
 
    switch (b.size()) {
        case 0:  // One candidate, no spatial variability
            break;
        case 1:  // eigen can't/won't handle 1x1 matrices
            x0(0) = b(0) / A(0, 0);
            break;
        default:
            x0 = A.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b);
            break;
    }
#if 0
    std::cout << "A " << A << std::endl;
    std::cout << "b " << b.transpose() << std::endl;
    std::cout << "x " << x.transpose() << std::endl;
 
    afw::image::Image<double> img(b.size(), b.size());
    for (int j = 0; j < b.size(); ++j) {
        for (int i = 0; i < b.size(); ++i) {
            img(i, j) = A(i, j);
        }
    }
    img.writeFits("a.fits");
 
    if (x.cols() >= 6) {
        for (int i = 0; i != 6; ++i) {
            double xcen = 25; double ycen = 35 + 35*i;
            std::cout << "x, y " << xcen << " , " << ycen << " b "
                      << (x[3] + xcen*x[4] + ycen*x[5])/(x[0] + xcen*x[1] + ycen*x[2]) << std::endl;
        }
    }
#endif
 
    // Generate kernel parameters (including 0th component) from matrix solution
    Eigen::VectorXd x(kernel->getNKernelParameters() * kernel->getNSpatialParameters());  // Kernel parameters
    x(0) = 1.0;
    std::fill(x.data() + 1, x.data() + kernel->getNSpatialParameters(), 0.0);
    std::copy(x0.data(), x0.data() + x0.size(), x.data() + kernel->getNSpatialParameters());
 
    setSpatialParameters(kernel, x);
    //
    // One time more through the Candidates setting their chi^2 values. We'll
    // do all the candidates this time, not just the first nStarPerCell
    //
    // visitor that evaluates the chi^2 of the current fit
    //
    evalChi2Visitor<PixelT> getChi2(*kernel, lambda);
 
    psfCells.visitAllCandidates(&getChi2, true);
 
    return std::make_pair(true, getChi2.getValue());
}

fitSpatialKernelFromPsfCandidates() [2/2]

template<typename PixelT >

std::pair< bool, double > lsst::meas::algorithms::fitSpatialKernelFromPsfCandidates	(	afw::math::Kernel *	kernel,
		afw::math::SpatialCellSet const &	psfCells,
		int const	nStarPerCell = -1,
		double const	tolerance = 1e-5,
		double const	lambda = 0.0 )

Fit spatial kernel using full-nonlinear optimization to estimate candidate amplitudes.

Parameters

kernel	the Kernel to fit
psfCells	A SpatialCellSet containing PsfCandidates
nStarPerCell	max no. of stars per cell; <= 0 => infty
tolerance	Tolerance; how close chi^2 should be to true minimum
lambda	floor for variance is lambda*data

Definition at line 592 of file SpatialModelPsf.cc.

          {
    int const nComponents = kernel->getNKernelParameters();
    int const nSpatialParams = kernel->getNSpatialParameters();
    //
    // visitor that evaluates the chi^2 of the current fit
    //
    evalChi2Visitor<PixelT> getChi2(*kernel, lambda);
    //
    // We have to unpack the Kernel coefficients into a linear array, coeffs
    //
    std::vector<double> coeffs;  // The coefficients we want to fit
    coeffs.assign(nComponents * nSpatialParams, 0.0);
 
    std::vector<double> stepSize;  // step sizes
    stepSize.assign(nComponents * nSpatialParams, 100);
    //
    // Translate that into minuit's language
    //
    ROOT::Minuit2::MnUserParameters fitPar;
    std::vector<std::string> paramNames;
    paramNames.reserve(nComponents * nSpatialParams);
 
    for (int i = 0, c = 0; c != nComponents; ++c) {
        coeffs[i] = 1;  // the constant part of each spatial order
        for (int s = 0; s != nSpatialParams; ++s, ++i) {
            paramNames.push_back((boost::format("C%d:%d") % c % s).str());
            fitPar.Add(paramNames[i].c_str(), coeffs[i], stepSize[i]);
        }
    }
    fitPar.Fix("C0:0");
    //
    // Create the minuit object that knows how to minimise our functor
    //
    MinimizeChi2<PixelT> minimizerFunc(getChi2, kernel, psfCells, nStarPerCell, nComponents, nSpatialParams);
 
    double const errorDef = 1.0;  // use +- 1sigma errors
    minimizerFunc.setErrorDef(errorDef);
    //
    // tell minuit about it
    //
    ROOT::Minuit2::MnMigrad migrad(minimizerFunc, fitPar);
    //
    // And let it loose
    //
    int maxFnCalls = 0;  // i.e. unlimited
    ROOT::Minuit2::FunctionMinimum min =
            migrad(maxFnCalls, tolerance / (1e-4 * errorDef));  // minuit uses 0.1*1e-3*tolerance*errorDef
 
    float minChi2 = min.Fval();
    bool const isValid = min.IsValid() && std::isfinite(minChi2);
 
    if (true || isValid) {  // calculate coeffs even in minuit is unhappy
        for (int i = 0; i != nComponents * nSpatialParams; ++i) {
            coeffs[i] = min.UserState().Value(i);
        }
 
        setSpatialParameters(kernel, coeffs);
    }
 
#if 0  // Estimate errors;  we don't really need this
    ROOT::Minuit2::MnMinos minos(minimizerFunc, min);
    for (int i = 0, c = 0; c != nComponents; ++c) {
        for (int s = 0; s != nSpatialParams; ++s, ++i) {
            char const *name = paramNames[i].c_str();
            printf("%s %g", name, min.UserState().Value(name));
            if (isValid && !fitPar.Parameter(fitPar.Index(name)).IsFixed()) {
                printf(" (%g+%g)\n", minos(i).first, minos(i).second);
            }
            printf("\n");
        }
    }
#endif
    //
    // One time more through the Candidates setting their chi^2 values. We'll
    // do all the candidates this time, not just the first nStarPerCell
    //
    psfCells.visitAllCandidates(&getChi2, true);
 
    return std::make_pair(isValid, minChi2);
}

getOverallBBox()

geom::Box2I lsst::meas::algorithms::getOverallBBox

(

std::vector< std::shared_ptr< afw::image::Image< double > > > const &

imgVector

)

Definition at line 189 of file CoaddPsf.cc.

                                                                                           {
    geom::Box2I bbox;
    // Calculate the box which will contain them all
    for (unsigned int i = 0; i < imgVector.size(); i++) {
        std::shared_ptr<afw::image::Image<double>> componentImg = imgVector[i];
        geom::Box2I cBBox = componentImg->getBBox();
        bbox.include(cBBox);  // JFB: this works even on empty bboxes
    }
    return bbox;
}

interpolateOverDefects()

template<typename MaskedImageT >

void lsst::meas::algorithms::interpolateOverDefects	(	MaskedImageT &	mimage,
		afw::detection::Psf const &	psf,
		std::vector< Defect::Ptr > &	_badList,
		double	fallbackValue = 0.0,
		bool	useFallbackValueAtEdge = false )

Process a set of known bad pixels in an image.

Parameters

mimage	Image to patch
psf	the Image's PSF (not yet used by interpolator)
_badList	List of Defects to patch
fallbackValue	Value to fallback to if all else fails
useFallbackValueAtEdge	Use the fallback value at the image's edge?

Definition at line 2047 of file Interp.cc.

  {
    /*
     * Allow for image's origin
     */
    int const width = mimage.getWidth();
    int const height = mimage.getHeight();
 
    std::vector<Defect::Ptr> badList;
    badList.reserve(_badList.size());
    for (std::vector<Defect::Ptr>::iterator ptr = _badList.begin(), end = _badList.end(); ptr != end; ++ptr) {
        geom::BoxI bbox = (*ptr)->getBBox();
        bbox.shift(geom::ExtentI(-mimage.getX0(), -mimage.getY0()));  // allow for image's origin
        geom::PointI min = bbox.getMin(), max = bbox.getMax();
        if (min.getX() >= width) {
            continue;
        } else if (min.getX() < 0) {
            if (max.getX() < 0) {
                continue;
            } else {
                min.setX(0);
            }
        }
 
        if (max.getX() < 0) {
            continue;
        } else if (max.getX() >= width) {
            max.setX(width - 1);
        }
 
        bbox = geom::BoxI(min, max);
        Defect::Ptr ndefect(new Defect(bbox));
        ndefect->classify((*ptr)->getPos(), (*ptr)->getType());
        badList.push_back(ndefect);
    }
 
    sort(badList.begin(), badList.end(), Sort_ByX0<Defect>());
    /*
     * Go through the frame looking at each pixel (except the edge ones which we ignore)
     */
    typename MaskedImageT::Mask::Pixel const interpBit =
            mimage.getMask()->getPlaneBitMask("INTRP");  // interp'd pixels
 
    constexpr int nUseInterp = 6;  // no. of pixels to interpolate towards edge
    static_assert(nUseInterp < Defect::WIDE_DEFECT,
                  "make sure that we can handle these defects using"
                  "the full interpolation not edge code");
 
    for (int y = 0; y != height; y++) {
        std::vector<Defect::Ptr> badList1D = classify_defects(badList, y, width);
 
        do_defects(badList1D, y, *mimage.getImage(),
                   -std::numeric_limits<typename MaskedImageT::Image::Pixel>::max(), fallbackValue,
                   useFallbackValueAtEdge, nUseInterp);
 
        do_defects(badList1D, y, *mimage.getMask(), interpBit, useFallbackValueAtEdge, nUseInterp);
 
        do_defects(badList1D, y, *mimage.getVariance(),
                   -std::numeric_limits<typename MaskedImageT::Image::Pixel>::max(), fallbackValue,
                   useFallbackValueAtEdge, nUseInterp);
    }
}

makeCoaddTransmissionCurve()

std::shared_ptr< afw::image::TransmissionCurve const > lsst::meas::algorithms::makeCoaddTransmissionCurve	(	std::shared_ptr< afw::geom::SkyWcs const >	coaddWcs,
		afw::table::ExposureCatalog const &	inputSensors )

Create a TransmissionCurve that represents the effective throughput on a coadd.

Parameters

[in]	coaddWcs	WCS that relates the coadd coordinate system to the sky.
[in]	inputSensors	A catalog containing the WCSs, bounding boxes and polygons, coaddition weights (in a field called 'weight'), and TransmissionCurves of the sensor-level images that went into the coadd.

Exceptions

NotFoundError	Thrown if the 'weight' field does not exist in the schema.
InvalidParameterError	Thrown if one or more inputs do not have a TransmissionCurve or a Wcs (ValidPolygons may be null to indicate no spatial restrictions other than the bounding box).

Returns

a new TransmissionCurve object.

Definition at line 257 of file CoaddTransmissionCurve.cc.

                                                                                                  {
    return std::make_shared<CoaddTransmissionCurve>(coaddWcs, inputSensors);
}

makeExposurePatch() [1/2]

template<typename ExposureT >

std::shared_ptr< ExposurePatch< ExposureT > > lsst::meas::algorithms::makeExposurePatch	(	std::shared_ptr< ExposureT const >	exp,
		afw::detection::Footprint const &	standardFoot,
		geom::Point2D const &	standardCenter,
		afw::geom::SkyWcs const &	standardWcs )

Definition at line 98 of file ExposurePatch.h.

                                                                                       {
    return std::make_shared<ExposurePatch<ExposureT> >(exp, standardFoot, standardCenter, standardWcs);
}

makeExposurePatch() [2/2]

template<typename ExposureT >

std::shared_ptr< ExposurePatch< ExposureT > > lsst::meas::algorithms::makeExposurePatch	(	std::shared_ptr< ExposureT const >	exp,
		std::shared_ptr< afw::detection::Footprint const >	foot,
		geom::Point2D const &	center )

Factory function for ExposurePatch.

Definition at line 92 of file ExposurePatch.h.

                                             {
    return std::make_shared<ExposurePatch<ExposureT> >(exp, foot, center);
}

makePsfCandidate()

template<typename PixelT >

std::shared_ptr< PsfCandidate< PixelT > > lsst::meas::algorithms::makePsfCandidate	(	std::shared_ptr< afw::table::SourceRecord > const &	source,
		std::shared_ptr< afw::image::Exposure< PixelT > >	image )

Return a PsfCandidate of the right sort.

Cf. std::make_pair

Parameters

source	The detected Source
image	The image wherein lies the object

Definition at line 176 of file PsfCandidate.h.

                                                         {
    return std::make_shared<PsfCandidate<PixelT>>(source, image);
}

PYBIND11_MODULE()

lsst::meas::algorithms::PYBIND11_MODULE	(	_algorithmsLib	,
		mod	)

Definition at line 49 of file _algorithmsLib.cc.

                                     {
WrapperCollection wrappers(mod, "lsst.meas.algorithms");
    wrappers.addInheritanceDependency("lsst.afw.geom");
    wrappers.addInheritanceDependency("lsst.afw.image");
    wrappers.addInheritanceDependency("lsst.afw.table");
    wrappers.addInheritanceDependency("lsst.afw.detection");
 
    wrapImagePsf(wrappers);
    wrapKernelPsf(wrappers);
    wrapCoaddTransmissionCurve(wrappers);
    wrapSingleGaussianPsf(wrappers);
    wrapDoubleGaussianPsf(wrappers);
    wrapInterp(wrappers);
    wrapPcaPsf(wrappers);
    wrapWarpedPsf(wrappers);
    wrapPsfCandidate(wrappers);
    wrapSpatialModelPsf(wrappers);
    wrapCoaddPsf(wrappers);
    wrapCoaddBoundedField(wrappers);
    wrapCr(wrappers);
    wrapCloughTocher2DInterpolatorUtils(wrappers);
    wrappers.finish();
}

setSpatialParameters() [1/2]

void lsst::meas::algorithms::setSpatialParameters	(	afw::math::Kernel *	kernel,
		Eigen::VectorXd const &	vec )

Fit a Kernel's spatial variability from a set of stars.

Definition at line 521 of file SpatialModelPsf.cc.

                                                                           {
    int const nComponents = kernel->getNKernelParameters();
    int const nSpatialParams = kernel->getNSpatialParameters();
 
    assert(nComponents * nSpatialParams == vec.size());
 
    std::vector<std::vector<double>> kCoeffs;  // coefficients rearranged for Kernel
    kCoeffs.reserve(nComponents);
    for (int i = 0; i != nComponents; ++i) {
        std::vector<double> spatialCoeffs(nSpatialParams);
        for (int j = 0; j != nSpatialParams; ++j) {
            spatialCoeffs[j] = vec[i * nSpatialParams + j];
        }
        kCoeffs.push_back(spatialCoeffs);
    }
 
    kernel->setSpatialParameters(kCoeffs);
}

setSpatialParameters() [2/2]

void lsst::meas::algorithms::setSpatialParameters	(	afw::math::Kernel *	kernel,
		std::vector< double > const &	coeffs )

Fit a Kernel's spatial variability from a set of stars.

Definition at line 500 of file SpatialModelPsf.cc.

                                                                                  {
    int const nComponents = kernel->getNKernelParameters();
    int const nSpatialParams = kernel->getNSpatialParameters();
 
    assert(nComponents * nSpatialParams == static_cast<long>(coeffs.size()));
 
    std::vector<std::vector<double>> kCoeffs;  // coefficients rearranged for Kernel
    kCoeffs.reserve(nComponents);
    for (int i = 0; i != nComponents; ++i) {
        kCoeffs.push_back(std::vector<double>(nSpatialParams));
        std::copy(coeffs.begin() + i * nSpatialParams, coeffs.begin() + (i + 1) * nSpatialParams,
                  kCoeffs[i].begin());
    }
 
    kernel->setSpatialParameters(kCoeffs);
}

subtractPsf() [1/2]

template<typename ImageT >

double lsst::meas::algorithms::subtractPsf	(	afw::detection::Psf const &	psf,
		ImageT *	data,
		double	x,
		double	y,
		double	psfFlux = std::numeric_limits< double >::quiet_NaN() )

subtractPsf() [2/2]

template<typename MaskedImageT >

double lsst::meas::algorithms::subtractPsf	(	afw::detection::Psf const &	psf,
		MaskedImageT *	data,
		double	x,
		double	y,
		double	psfFlux )

Subtract a PSF from an image at a given position.

Parameters

psf	the PSF to subtract
data	Image to subtract PSF from
x	column position
y	row position
psfFlux	object's PSF flux (if not NaN)

Definition at line 976 of file SpatialModelPsf.cc.

                     {
    if (std::isnan(x + y)) {
        return std::numeric_limits<double>::quiet_NaN();
    }
 
    //
    // Get Psf candidate
    //
    std::shared_ptr<afw::detection::Psf::Image> kImage = psf.computeImage(geom::PointD(x, y));
 
    //
    // Now find the proper sub-Image
    //
    geom::BoxI bbox = kImage->getBBox();
 
    std::shared_ptr<MaskedImageT> subData(
            new MaskedImageT(*data, bbox, afw::image::PARENT, false));  // shallow copy
    //
    // Now we've got both; find the PSF's amplitude
    //
    double lambda = 0.0;  // floor for variance is lambda*data
    try {
        double chi2;  // chi^2 for fit
        double amp;   // estimate of amplitude of model at this point
 
        if (std::isnan(psfFlux)) {
            std::pair<double, double> result = fitKernel(*kImage, *subData, lambda, true);
            chi2 = result.first;  // chi^2 for fit
            amp = result.second;  // estimate of amplitude of model at this point
        } else {
            chi2 = std::numeric_limits<double>::quiet_NaN();
            amp = psfFlux / afw::math::makeStatistics(*kImage, afw::math::SUM).getValue();
        }
        //
        // Convert kImage to the proper type so that I can subtract it.
        //
        std::shared_ptr<typename MaskedImageT::Image> kImageF(
                new typename MaskedImageT::Image(*kImage, true));  // of data's type
 
        *kImageF *= amp;
        *subData->getImage() -= *kImageF;
 
        return chi2;
    } catch (lsst::pex::exceptions::RangeError& e) {
        LSST_EXCEPT_ADD(e, (boost::format("Object at (%.2f, %.2f)") % x % y).str());
        throw e;
    }
}

wrapCloughTocher2DInterpolatorUtils()

void lsst::meas::algorithms::wrapCloughTocher2DInterpolatorUtils

(

WrapperCollection &

wrappers

)

Definition at line 58 of file cloughTocher2DInterpolatorUtils.cc.

                                                                                        {
    declareCloughTocher2DInterpolatorUtils(wrappers);
}

wrapCoaddBoundedField()

void lsst::meas::algorithms::wrapCoaddBoundedField

(

WrapperCollection &

wrappers

)

Definition at line 88 of file coaddBoundedField.cc.

                                                                          {
    declareCoaddBoundedField(wrappers);
}

wrapCoaddPsf()

void lsst::meas::algorithms::wrapCoaddPsf

(

WrapperCollection &

wrappers

)

Definition at line 82 of file coaddPsf.cc.

{
    declareCoaddPsf(wrappers);
}

wrapCoaddTransmissionCurve()

void lsst::meas::algorithms::wrapCoaddTransmissionCurve

(

WrapperCollection &

wrappers

)

Definition at line 35 of file coaddTransmissionCurve.cc.

                                                                               {
    wrappers.module.def("makeCoaddTransmissionCurve", &makeCoaddTransmissionCurve, "coaddWcs"_a, "inputSensors"_a);
}

wrapCr()

void lsst::meas::algorithms::wrapCr

(

WrapperCollection &

wrappers

)

Definition at line 44 of file cr.cc.

                                                           {
    declareFindCosmicRays<float>(wrappers);
}

wrapDoubleGaussianPsf()

void lsst::meas::algorithms::wrapDoubleGaussianPsf

(

WrapperCollection &

wrappers

)

Definition at line 52 of file doubleGaussianPsf.cc.

                                                                          {
    declareDoubleGaussianPsf(wrappers);
}

wrapImagePsf()

void lsst::meas::algorithms::wrapImagePsf

(

WrapperCollection &

wrappers

)

Definition at line 49 of file imagePsf.cc.

                                                                 {
    declareImagePsf(wrappers);
}

wrapInterp()

void lsst::meas::algorithms::wrapInterp

(

WrapperCollection &

wrappers

)

Definition at line 72 of file interp.cc.

{
    declareInterp(wrappers);
}

wrapKernelPsf()

void lsst::meas::algorithms::wrapKernelPsf

(

WrapperCollection &

wrappers

)

Definition at line 51 of file kernelPsf.cc.

                                                                  {
    declareKernelPsf(wrappers);
}

wrapPcaPsf()

void lsst::meas::algorithms::wrapPcaPsf

(

WrapperCollection &

wrappers

)

Definition at line 51 of file pcaPsf.cc.

                                                               {
    declarePcaPsf(wrappers);
}

wrapPsfCandidate()

void lsst::meas::algorithms::wrapPsfCandidate

(

WrapperCollection &

wrappers

)

Definition at line 79 of file psfCandidate.cc.

                                                                     {
    declarePsfCandidate<float>(wrappers, "F");
}

wrapSingleGaussianPsf()

void lsst::meas::algorithms::wrapSingleGaussianPsf

(

WrapperCollection &

wrappers

)

Definition at line 50 of file singleGaussianPsf.cc.

                                                                          {
    declareSingleGaussianPsf(wrappers);
}

wrapSpatialModelPsf()

void lsst::meas::algorithms::wrapSpatialModelPsf

(

WrapperCollection &

wrappers

)

Definition at line 61 of file spatialModelPsf.cc.

                                                                        {
    declareFunctions<float>(wrappers);
}

wrapWarpedPsf()

void lsst::meas::algorithms::wrapWarpedPsf

(

WrapperCollection &

wrappers

)

Definition at line 58 of file warpedPsf.cc.

                                                                  {
    declareWarpedPsf(wrappers);
}