Namespace lsst::meas::algorithms

namespace algorithms

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.

Return

a new TransmissionCurve object.

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).

template<typename MaskedImageT>
std::vector<std::shared_ptr<afw::detection::Footprint>> findCosmicRays(MaskedImageT &image, afw::detection::Psf const &psf, double const bkgd, daf::base::PropertySet const &ps, bool const keep = false)
template<typename ExposureT>
PTR(ExposurePatch<ExposureT>)

Factory function for ExposurePatch.

CONST_PTR(afw::detection::Footprint)
template<typename MaskedImageT>
void interpolateOverDefects(MaskedImageT &image, afw::detection::Psf const &psf, std::vector<Defect::Ptr> &badList, double fallbackValue = 0.0, bool useFallbackValueAtEdge = false)
template<typename PixelT>std::shared_ptr<PsfCandidate<PixelT> > lsst::meas::algorithms::makePsfCandidate(PTR( afw::table::SourceRecord ) const & source, PTR( afw::image::Exposure < PixelT >) image)

Parameters

  • source: The detected Source

  • image: The image wherein lies the object

Return a PsfCandidate of the right sort

Cf. std::make_pair

template<typename PixelT>
std::pair<std::shared_ptr<afw::math::LinearCombinationKernel>, std::vector<double>> createKernelFromPsfCandidates(afw::math::SpatialCellSet const &psfCells, geom::Extent2I const &dims, geom::Point2I const &xy0, int const nEigenComponents, int const spatialOrder, int const ksize, int const nStarPerCell = -1, bool const constantWeight = true, int const border = 3)
template<typename PixelT>
int countPsfCandidates(afw::math::SpatialCellSet const &psfCells, int const nStarPerCell = -1)
template<typename PixelT>
std::pair<bool, double> fitSpatialKernelFromPsfCandidates(afw::math::Kernel *kernel, afw::math::SpatialCellSet const &psfCells, int const nStarPerCell = -1, double const tolerance = 1e-5, double const lambda = 0.0)
template<typename PixelT>
std::pair<bool, double> 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)
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)
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)

Variables

geom::Point2D const& lsst::meas::algorithms::center{ return std::make_shared<ExposurePatch<ExposureT> >(exp, foot, center)
afw::detection::Footprint const &standardFoot
afw::detection::Footprint const geom::Point2D const& lsst::meas::algorithms::standardCenter
afw::detection::Footprint const geom::Point2D const afw::geom::SkyWcs const& lsst::meas::algorithms::standardWcs{ return std::make_shared<ExposurePatch<ExposureT> >(exp, standardFoot, standardCenter, standardWcs)
struct CoaddBoundedFieldElement
#include <CoaddBoundedField.h>

Struct used to hold one Exposure’s data in a CoaddBoundedField.

class CoaddPsf : public lsst::afw::table::io::PersistableFacade<CoaddPsf>, public lsst::meas::algorithms::ImagePsf
#include <CoaddPsf.h>

CoaddPsf is the Psf derived to be used for non-PSF-matched Coadd images.

It incorporates the logic of James Jee’s Stackfit algorithm for estimating the Psf of coadd by coadding the images of the Psf models of each input exposure.

class Defect : public lsst::afw::image::DefectBase
#include <Interp.h>

Encapsulate information about a bad portion of a detector.

class DoubleGaussianPsf : public lsst::afw::table::io::PersistableFacade<DoubleGaussianPsf>, public lsst::meas::algorithms::KernelPsf
#include <DoubleGaussianPsf.h>

Represent a Psf as a circularly symmetrical double Gaussian.

template<typename ExposureT>
class ExposurePatch
#include <ExposurePatch.h>

A convenience container for the exposure, peak and footprint that will be measured.

This is more useful than a std::pair or similar.

class ImagePsf : public lsst::afw::table::io::PersistableFacade<ImagePsf>, public lsst::afw::detection::Psf
#include <ImagePsf.h>

An intermediate base class for Psfs that use an image representation.

ImagePsf exists only to provide implementations of doComputeApertureFlux and doComputeShape for its derived classes. These implementations use the SincFlux and SdssShape algorithms defined in meas_algorithms, and hence could not be included with the Psf base class in afw.

Subclassed by lsst::meas::algorithms::CoaddPsf, lsst::meas::algorithms::KernelPsf, lsst::meas::algorithms::WarpedPsf, lsst::meas::extensions::psfex::PsfexPsf

class KernelPsf : public lsst::afw::table::io::PersistableFacade<KernelPsf>, public lsst::meas::algorithms::ImagePsf
#include <KernelPsf.h>

A Psf defined by a Kernel.

Subclassed by lsst::meas::algorithms::DoubleGaussianPsf, lsst::meas::algorithms::PcaPsf, lsst::meas::algorithms::SingleGaussianPsf

template<typename T = KernelPsf, typename K = afw::math::Kernel>
class KernelPsfFactory : public lsst::afw::table::io::PersistableFactory
#include <KernelPsfFactory.h>

A PersistableFactory for KernelPsf and its subclasses.

If a KernelPsf subclass has no data members other than its kernel, table persistence for it can be implemented simply by reimplementing getPersistenceName() and registering a specialization of KernelPsfFactory.

Template Parameters

  • T: KernelPsf subclass the factory will construct.

  • K: Kernel subclass the Psf constructor requires.

struct KernelPsfPersistenceHelper
#include <KernelPsfFactory.h>

A read-only singleton struct containing the schema and key used in persistence for KernelPsf.

class PcaPsf : public lsst::afw::table::io::PersistableFacade<PcaPsf>, public lsst::meas::algorithms::KernelPsf
#include <PcaPsf.h>

Represent a PSF as a linear combination of PCA (== Karhunen-Loeve) basis functions.

template<typename PixelT>
class PsfCandidate : public lsst::afw::math::SpatialCellImageCandidate
#include <PsfCandidate.h>

Class stored in SpatialCells for spatial Psf fitting.

PsfCandidate is a detection that may turn out to be a PSF. We’ll assign them to sets of SpatialCells; these sets will then be used to fit a spatial model to the PSF.

class SingleGaussianPsf : public lsst::afw::table::io::PersistableFacade<SingleGaussianPsf>, public lsst::meas::algorithms::KernelPsf
#include <SingleGaussianPsf.h>

Represent a PSF as a circularly symmetrical Gaussian.

class WarpedPsf : public lsst::meas::algorithms::ImagePsf
#include <WarpedPsf.h>

A Psf class that maps an arbitrary Psf through a coordinate transformation.

If K_0(x,x’) is the unwarped PSF, and f is the coordinate transform, then the warped PSF is defined by

K(f(x),f(x’)) = K_0(x,x’) (*)

We linearize the coordinate transform in the vicinity of the point where the PSF is computed. The definition (*) does not include the Jacobian of the transformation, since the afw convention is that PSF’s are normalized to have integral 1 anyway.

namespace interp

Functions

template<typename MaskedImageT>
std::pair<bool, typename MaskedImageT::Image::Pixel> singlePixel(int x, int y, MaskedImageT const &image, bool horizontal, double minval)

Variables

double const lpc_1_c1 = 0.7737

LPC coefficients for sigma = 1, S/N = infty

double const lpc_1_c2 = -0.2737
double const lpc_1s2_c1 = 0.7358

LPC coefficients for sigma = 1/sqrt(2), S/N = infty. These are the coeffs to use when interpolating at 45degrees to the row/column

double const lpc_1s2_c2 = -0.2358
double const min2GaussianBias = -0.5641895835

Mean value of the minimum of two N(0,1) variates.