lsst::afw::table Namespace Reference

Namespaces
namespace	_aggregates
namespace	_aliasMap
namespace	_arrays
namespace	_base
namespace	_baseColumnView
namespace	_exposure
namespace	_match
namespace	_schema
namespace	_schemaMapper
namespace	_simple
namespace	_source
namespace	catalogMatches
namespace	detail
namespace	io
namespace	multiMatch
namespace	python
namespace	testUtils

Classes
class	AliasMap
	Mapping class that holds aliases for a Schema. More...
class	Array
	Tag types used to declare specialized field types. More...
class	ArrayKey
	A FunctorKey used to get or set a ndarray::Array from a sequence of scalar Keys. More...
class	BaseColumnView
	Column-wise view into a sequence of records that have been allocated contiguously. More...
class	BaseRecord
	Base class for all records. More...
class	BaseTable
	Base class for all tables. More...
class	BitsColumn
	A packed representation of a collection of Flag field columns. More...
class	BoxKey
	A FunctorKey used to get or set a lsst::geom::Box2I or Box2D from a (min, max) pair of Point3Keys. More...
class	CatalogIterator
	Iterator class for CatalogT. More...
class	CatalogT
	A custom container class for records, based on std::vector. More...
class	CentroidSlotDefinition
	SlotDefinition specialization for centroids. More...
class	ColumnViewT
class	ConstReferenceFunctorKey
	Base class for objects that can return a const reference to part of a record, but are not a true Key. More...
class	CoordErrKey
class	CoordKey
	A FunctorKey used to get or set celestial coordinates from a pair of lsst::geom::Angle keys. More...
class	CovarianceMatrixKey
class	EllipseKey
	A FunctorKey used to get or set a geom::ellipses::Ellipse from an (xx,yy,xy,x,y) tuple of Keys. More...
class	ExposureCatalogT
	Custom catalog class for ExposureRecord/Table. More...
class	ExposureRecord
	Record class used to store exposure metadata. More...
class	ExposureTable
	Table class used to store exposure metadata. More...
struct	Field
	A description of a field in a table. More...
struct	FieldBase
	Field base class default implementation (used for numeric scalars and lsst::geom::Angle). More...
struct	FieldBase< Array< U > >
	Field base class specialization for arrays. More...
struct	FieldBase< Flag >
	Specialization for Flag fields. More...
struct	FieldBase< std::string >
	Field base class specialization for strings. More...
class	FluxSlotDefinition
	SlotDefinition specialization for fluxes. More...
class	FunctorKey
	Convenience base class that combines the OutputFunctorKey and InputFunctorKey. More...
class	IdFactory
	A polymorphic functor base class for generating record IDs for a table. More...
class	InputFunctorKey
	Base class for objects that can set a value on a record, but are not a true Key themselves. More...
class	Key
	A class used as a handle to a particular field in a table. More...
class	Key< Flag >
	Key specialization for Flag. More...
class	KeyBase
	A base class for Key that allows subfield keys to be extracted for some field types. More...
class	KeyBase< Array< U > >
	KeyBase specialization for Arrays. More...
class	KeyBase< Flag >
	A base class for Key that allows the underlying storage field to be extracted. More...
struct	Match
	Lightweight representation of a geometric match between two records. More...
class	MatchControl
	Pass parameters to algorithms that match list of sources. More...
class	OutputFunctorKey
	Base class for objects that can extract a value from a record, but are not a true Key themselves. More...
class	PersistableObjectColumnReader
class	Point3Key
	A FunctorKey used to get or set a lsst::geom::Point3 from an (x,y,z) tuple of int or double Keys. More...
class	PointKey
	A FunctorKey used to get or set a lsst::geom::Point from an (x,y) pair of int or double Keys. More...
class	QuadrupoleKey
	A FunctorKey used to get or set a geom::ellipses::Quadrupole from a tuple of constituent Keys. More...
class	ReferenceFunctorKey
	Base class for objects that can return a non-const reference to part of a record, but are not a true Key. More...
class	Schema
	Defines the fields and offsets for a table. More...
struct	SchemaItem
	A simple pair-like struct for mapping a Field (name and description) with a Key (used for actual data access). More...
class	SchemaMapper
	A mapping between the keys of two Schemas, used to copy data between them. More...
class	ShapeSlotDefinition
	SlotDefinition specialization for shapes. More...
class	SimpleRecord
	Record class that must contain a unique ID field and a celestial coordinate field. More...
class	SimpleTable
	Table class that must contain a unique ID field and a celestial coordinate field. More...
class	SlotDefinition
	Base class for helper classes that define slots on SourceTable/SourceRecord. More...
struct	SlotSuite
	An aggregate containing all of the current slots used in SourceTable. More...
class	SortedCatalogT
	Custom catalog class for record/table subclasses that are guaranteed to have an ID, and should generally be sorted by that ID. More...
class	SourceColumnViewT
class	SourceRecord
	Record class that contains measurements made on a single exposure. More...
class	SourceTable
	Table class that contains measurements made on a single exposure. More...
class	SubSchema
	A proxy type for name lookups in a Schema. More...
struct	TypeList

Typedefs
using	Point2IKey = PointKey<int>
using	Point2DKey = PointKey<double>
using	Point3IKey = Point3Key<int>
using	Point3DKey = Point3Key<double>
using	Box2IKey = BoxKey<lsst::geom::Box2I>
using	Box2DKey = BoxKey<lsst::geom::Box2D>
using	ExposureColumnView = ColumnViewT<ExposureRecord>
using	ExposureCatalog = ExposureCatalogT<ExposureRecord>
using	ConstExposureCatalog = ExposureCatalogT<const ExposureRecord>
using	BaseCatalog = CatalogT<BaseRecord>
using	ConstBaseCatalog = CatalogT<const BaseRecord>
using	SimpleColumnView = ColumnViewT<SimpleRecord>
using	SimpleCatalog = SortedCatalogT<SimpleRecord>
using	ConstSimpleCatalog = SortedCatalogT<const SimpleRecord>
using	SourceColumnView = SourceColumnViewT<SourceRecord>
using	SourceCatalog = SortedCatalogT<SourceRecord>
using	ConstSourceCatalog = SortedCatalogT<const SourceRecord>
using	AmpInfoColumnView = ColumnViewT<AmpInfoRecord>
using	AmpInfoCatalog = CatalogT<AmpInfoRecord>
using	ConstAmpInfoCatalog = CatalogT<const AmpInfoRecord>
using	SimpleMatch = Match<SimpleRecord, SimpleRecord>
using	ReferenceMatch = Match<SimpleRecord, SourceRecord>
using	SourceMatch = Match<SourceRecord, SourceRecord>
using	SimpleMatchVector = std::vector<SimpleMatch>
using	ReferenceMatchVector = std::vector<ReferenceMatch>
using	SourceMatchVector = std::vector<SourceMatch>
using	RecordId = std::int64_t
	Type used for unique IDs for records.
using	Angle = lsst::geom::Angle
using	SpherePoint = lsst::geom::SpherePoint
using	Footprint = lsst::afw::detection::Footprint
using	FieldTypes = TypeList< RecordId, std::uint16_t, std::int32_t, float, double, lsst::geom::Angle, std::uint8_t , Flag, std::string, Array<std::uint16_t>, Array<int>, Array<float>, Array<double>, Array<std::uint8_t> >
	A compile-time list of all field types.
using	PyAliasMap = py::class_<AliasMap, std::shared_ptr<AliasMap>>
using	PyIdFactory = py::class_<IdFactory, std::shared_ptr<IdFactory>>
using	PySchemaMapper = py::class_<SchemaMapper, std::shared_ptr<SchemaMapper>>

Enumerations
enum class	CoordinateType { PIXEL , CELESTIAL }
	Enum used to set units for geometric FunctorKeys. More...
enum	SourceFitsFlags { SOURCE_IO_NO_FOOTPRINTS = 0x1 , SOURCE_IO_NO_HEAVY_FOOTPRINTS = 0x2 }
	Bitflags to be passed to SourceCatalog::readFits and SourceCatalog::writeFits. More...

Functions
template<typename RecordT , typename Catalog , typename T >
std::shared_ptr< RecordT >	_Catalog_find (Catalog const &catalog, T const &value, Key< T > const &key)
template<typename Catalog , typename T >
int	_Catalog_lower_bound (Catalog const &catalog, T const &value, Key< T > const &key)
template<typename Catalog , typename T >
int	_Catalog_upper_bound (Catalog const &catalog, T const &value, Key< T > const &key)
template<typename Catalog , typename T >
std::pair< int, int >	_Catalog_equal_range (Catalog const &catalog, T const &value, Key< T > const &key)
SourceMatchVector	matchXy (SourceCatalog const &cat1, SourceCatalog const &cat2, double radius, MatchControl const &mc=MatchControl())
	Compute all tuples (s1,s2,d) where s1 belings to cat1, s2 belongs to cat2 and d, the distance between s1 and s2, in pixels, is at most radius.
SourceMatchVector	matchXy (SourceCatalog const &cat, double radius, MatchControl const &mc=MatchControl())
	Compute all tuples (s1,s2,d) where s1 != s2, s1 and s2 both belong to cat, and d, the distance between s1 and s2, in pixels, is at most radius.
template<typename Cat1 , typename Cat2 >
std::vector< Match< typename Cat1::Record, typename Cat2::Record > >	matchRaDec (Cat1 const &cat1, Cat2 const &cat2, lsst::geom::Angle radius, MatchControl const &mc=MatchControl())
	Compute all tuples (s1,s2,d) where s1 belings to cat1, s2 belongs to cat2 and d, the distance between s1 and s2, is at most radius.
template<typename Cat >
std::vector< Match< typename Cat::Record, typename Cat::Record > >	matchRaDec (Cat const &cat, lsst::geom::Angle radius, MatchControl const &mc=MatchControl())
template<typename Record1 , typename Record2 >
BaseCatalog	packMatches (std::vector< Match< Record1, Record2 > > const &matches)
	Return a table representation of a MatchVector that can be used to persist it.
template<typename Cat1 , typename Cat2 >
std::vector< Match< typename Cat1::Record, typename Cat2::Record > >	unpackMatches (BaseCatalog const &matches, Cat1 const &cat1, Cat2 const &cat2)
	Reconstruct a MatchVector from a BaseCatalog representation of the matches and a pair of catalogs.
template<typename ReferenceCollection >
void	updateRefCentroids (geom::SkyWcs const &wcs, ReferenceCollection &refList)
	Update centroids in a collection of reference objects.
template<typename SourceCollection >
void	updateSourceCoords (geom::SkyWcs const &wcs, SourceCollection &sourceList, bool include_covariance=true)
	Update sky coordinates in a collection of source objects.
Eigen::Matrix2f	calculateCoordCovariance (geom::SkyWcs const &wcs, lsst::geom::Point2D center, Eigen::Matrix2f err)
	Calculate covariance for sky coordinates.
void	wrapAggregates (WrapperCollection &wrappers)
void	wrapAliasMap (cpputils::python::WrapperCollection &wrappers)
void	wrapArrays (WrapperCollection &wrappers)
void	wrapBase (WrapperCollection &wrappers)
void	wrapBaseColumnView (WrapperCollection &wrappers)
void	wrapExposure (WrapperCollection &wrappers)
void	wrapIdFactory (cpputils::python::WrapperCollection &wrappers)
void	wrapMatch (WrapperCollection &wrappers)
void	wrapSchema (WrapperCollection &wrappers)
void	wrapSchemaMapper (WrapperCollection &wrappers)
void	wrapSimple (WrapperCollection &wrappers)
void	wrapSlots (WrapperCollection &wrappers)
void	wrapSource (WrapperCollection &wrappers)
void	wrapWcsUtils (WrapperCollection &)
	PYBIND11_MODULE (_table, mod)
	BOOST_PP_SEQ_FOR_EACH (INSTANTIATE_COLUMNVIEW_SCALAR, _, BOOST_PP_TUPLE_TO_SEQ(AFW_TABLE_SCALAR_FIELD_TYPE_N, AFW_TABLE_SCALAR_FIELD_TYPE_TUPLE)) BOOST_PP_SEQ_FOR_EACH(INSTANTIATE_COLUMNVIEW_ARRAY
std::ostream &	operator<< (std::ostream &os, BaseRecord const &record)
template<typename Cat1 , typename Cat2 >
std::vector< Match< typename Cat1::Record, typename Cat2::Record > >	matchRaDec (Cat1 const &cat1, Cat2 const &cat2, lsst::geom::Angle radius, bool closest)
template SimpleMatchVector	matchRaDec (SimpleCatalog const &, SimpleCatalog const &, lsst::geom::Angle, bool)
template SimpleMatchVector	matchRaDec (SimpleCatalog const &, SimpleCatalog const &, lsst::geom::Angle, MatchControl const &)
template ReferenceMatchVector	matchRaDec (SimpleCatalog const &, SourceCatalog const &, lsst::geom::Angle, bool)
template ReferenceMatchVector	matchRaDec (SimpleCatalog const &, SourceCatalog const &, lsst::geom::Angle, MatchControl const &)
template SourceMatchVector	matchRaDec (SourceCatalog const &, SourceCatalog const &, lsst::geom::Angle, bool)
template SourceMatchVector	matchRaDec (SourceCatalog const &, SourceCatalog const &, lsst::geom::Angle, MatchControl const &)
template<typename Cat >
std::vector< Match< typename Cat::Record, typename Cat::Record > >	matchRaDec (Cat const &cat, lsst::geom::Angle radius, bool symmetric)
template SimpleMatchVector	matchRaDec (SimpleCatalog const &, lsst::geom::Angle, bool)
template SimpleMatchVector	matchRaDec (SimpleCatalog const &, lsst::geom::Angle, MatchControl const &)
template SourceMatchVector	matchRaDec (SourceCatalog const &, lsst::geom::Angle, bool)
template SourceMatchVector	matchRaDec (SourceCatalog const &, lsst::geom::Angle, MatchControl const &)
SourceMatchVector	matchXy (SourceCatalog const &cat1, SourceCatalog const &cat2, double radius, bool closest)
SourceMatchVector	matchXy (SourceCatalog const &cat, double radius, bool symmetric)
template BaseCatalog	packMatches (SimpleMatchVector const &)
template BaseCatalog	packMatches (ReferenceMatchVector const &)
template BaseCatalog	packMatches (SourceMatchVector const &)
template SimpleMatchVector	unpackMatches (BaseCatalog const &, SimpleCatalog const &, SimpleCatalog const &)
template ReferenceMatchVector	unpackMatches (BaseCatalog const &, SimpleCatalog const &, SourceCatalog const &)
template SourceMatchVector	unpackMatches (BaseCatalog const &, SourceCatalog const &, SourceCatalog const &)
std::ostream &	operator<< (std::ostream &os, Schema const &schema)

Variables
	_

Typedef Documentation

AmpInfoCatalog

using lsst::afw::table::AmpInfoCatalog = CatalogT<AmpInfoRecord>

Definition at line 97 of file fwd.h.

AmpInfoColumnView

using lsst::afw::table::AmpInfoColumnView = ColumnViewT<AmpInfoRecord>

Definition at line 96 of file fwd.h.

Angle

using lsst::afw::table::Angle = lsst::geom::Angle

Definition at line 33 of file misc.h.

BaseCatalog

typedef CatalogT< BaseRecord > lsst::afw::table::BaseCatalog = CatalogT<BaseRecord>

Definition at line 72 of file fwd.h.

Box2DKey

using lsst::afw::table::Box2DKey = BoxKey<lsst::geom::Box2D>

Definition at line 284 of file aggregates.h.

Box2IKey

using lsst::afw::table::Box2IKey = BoxKey<lsst::geom::Box2I>

Definition at line 283 of file aggregates.h.

ConstAmpInfoCatalog

using lsst::afw::table::ConstAmpInfoCatalog = CatalogT<const AmpInfoRecord>

Definition at line 98 of file fwd.h.

ConstBaseCatalog

using lsst::afw::table::ConstBaseCatalog = CatalogT<const BaseRecord>

Definition at line 73 of file fwd.h.

ConstExposureCatalog

typedef ExposureCatalogT< const ExposureRecord > lsst::afw::table::ConstExposureCatalog = ExposureCatalogT<const ExposureRecord>

Definition at line 489 of file Exposure.h.

ConstSimpleCatalog

using lsst::afw::table::ConstSimpleCatalog = SortedCatalogT<const SimpleRecord>

Definition at line 80 of file fwd.h.

ConstSourceCatalog

using lsst::afw::table::ConstSourceCatalog = SortedCatalogT<const SourceRecord>

Definition at line 86 of file fwd.h.

ExposureCatalog

typedef ExposureCatalogT< ExposureRecord > lsst::afw::table::ExposureCatalog = ExposureCatalogT<ExposureRecord>

Definition at line 488 of file Exposure.h.

ExposureColumnView

typedef ColumnViewT< ExposureRecord > lsst::afw::table::ExposureColumnView = ColumnViewT<ExposureRecord>

Definition at line 487 of file Exposure.h.

FieldTypes

using lsst::afw::table::FieldTypes = TypeList< RecordId, std::uint16_t, std::int32_t, float, double, lsst::geom::Angle, std::uint8_t , Flag, std::string, Array<std::uint16_t>, Array<int>, Array<float>, Array<double>, Array<std::uint8_t> >

A compile-time list of all field types.

Definition at line 53 of file types.h.

Footprint

using lsst::afw::table::Footprint = lsst::afw::detection::Footprint

Definition at line 57 of file Source.h.

Point2DKey

using lsst::afw::table::Point2DKey = PointKey<double>

Definition at line 120 of file aggregates.h.

Point2IKey

using lsst::afw::table::Point2IKey = PointKey<int>

Definition at line 119 of file aggregates.h.

Point3DKey

using lsst::afw::table::Point3DKey = Point3Key<double>

Definition at line 200 of file aggregates.h.

Point3IKey

using lsst::afw::table::Point3IKey = Point3Key<int>

Definition at line 199 of file aggregates.h.

PyAliasMap

using lsst::afw::table::PyAliasMap = py::class_<AliasMap, std::shared_ptr<AliasMap>>

Definition at line 37 of file _aliasMap.cc.

PyIdFactory

using lsst::afw::table::PyIdFactory = py::class_<IdFactory, std::shared_ptr<IdFactory>>

Definition at line 36 of file _idFactory.cc.

PySchemaMapper

using lsst::afw::table::PySchemaMapper = py::class_<SchemaMapper, std::shared_ptr<SchemaMapper>>

Definition at line 43 of file _schemaMapper.cc.

RecordId

using lsst::afw::table::RecordId = std::int64_t

Type used for unique IDs for records.

FITS isn't fond of uint64, so we can save a lot of pain by using signed ints here unless we really need unsigned.

Definition at line 21 of file misc.h.

ReferenceMatch

typedef Match< SimpleRecord, SourceRecord > lsst::afw::table::ReferenceMatch = Match<SimpleRecord, SourceRecord>

Definition at line 104 of file fwd.h.

ReferenceMatchVector

typedef std::vector< ReferenceMatch > lsst::afw::table::ReferenceMatchVector = std::vector<ReferenceMatch>

Definition at line 108 of file fwd.h.

SimpleCatalog

using lsst::afw::table::SimpleCatalog = SortedCatalogT<SimpleRecord>

Definition at line 79 of file fwd.h.

SimpleColumnView

using lsst::afw::table::SimpleColumnView = ColumnViewT<SimpleRecord>

Definition at line 78 of file fwd.h.

SimpleMatch

typedef Match< SimpleRecord, SimpleRecord > lsst::afw::table::SimpleMatch = Match<SimpleRecord, SimpleRecord>

Definition at line 103 of file fwd.h.

SimpleMatchVector

typedef std::vector< SimpleMatch > lsst::afw::table::SimpleMatchVector = std::vector<SimpleMatch>

Definition at line 107 of file fwd.h.

SourceCatalog

using lsst::afw::table::SourceCatalog = SortedCatalogT<SourceRecord>

Definition at line 85 of file fwd.h.

SourceColumnView

typedef SourceColumnViewT< SourceRecord > lsst::afw::table::SourceColumnView = SourceColumnViewT<SourceRecord>

Definition at line 84 of file fwd.h.

SourceMatch

typedef Match< SourceRecord, SourceRecord > lsst::afw::table::SourceMatch = Match<SourceRecord, SourceRecord>

Definition at line 105 of file fwd.h.

SourceMatchVector

typedef std::vector< SourceMatch > lsst::afw::table::SourceMatchVector = std::vector<SourceMatch>

Definition at line 109 of file fwd.h.

SpherePoint

using lsst::afw::table::SpherePoint = lsst::geom::SpherePoint

Definition at line 34 of file misc.h.

Enumeration Type Documentation

CoordinateType

enum class lsst::afw::table::CoordinateType

strong

Enum used to set units for geometric FunctorKeys.

Enumerator
PIXEL
CELESTIAL

Definition at line 364 of file aggregates.h.

{ PIXEL, CELESTIAL };

SourceFitsFlags

enum lsst::afw::table::SourceFitsFlags

Bitflags to be passed to SourceCatalog::readFits and SourceCatalog::writeFits.

Note that these flags may also be passed when reading/writing SourceCatalogs via the Butler, by passing a "flags" key/value pair as part of the data ID.

Enumerator
SOURCE_IO_NO_FOOTPRINTS	Do not read/write footprints at all.
SOURCE_IO_NO_HEAVY_FOOTPRINTS	Read/write heavy footprints as non-heavy footprints.

Definition at line 52 of file Source.h.

                     {
    SOURCE_IO_NO_FOOTPRINTS = 0x1,       
    SOURCE_IO_NO_HEAVY_FOOTPRINTS = 0x2  
};

Function Documentation

_Catalog_equal_range()

template<typename Catalog , typename T >

std::pair< int, int > lsst::afw::table::_Catalog_equal_range	(	Catalog const &	catalog,
		T const &	value,
		Key< T > const &	key )

Definition at line 912 of file Catalog.h.

                                                                                                  {
    std::pair<typename Catalog::const_iterator, typename Catalog::const_iterator> p =
            catalog.equal_range(value, key);
    return std::pair<int, int>(p.first - catalog.begin(), p.second - catalog.begin());
}

_Catalog_find()

template<typename RecordT , typename Catalog , typename T >

std::shared_ptr< RecordT > lsst::afw::table::_Catalog_find	(	Catalog const &	catalog,
		T const &	value,
		Key< T > const &	key )

Definition at line 893 of file Catalog.h.

                                                                                                {
    typename Catalog::const_iterator iter = catalog.find(value, key);
    if (iter == catalog.end()) {
        return std::shared_ptr<RecordT>();
    }
    return iter;  // n.b. CatalogIterator is explicitly convertible to shared_ptr
}

_Catalog_lower_bound()

template<typename Catalog , typename T >

int lsst::afw::table::_Catalog_lower_bound	(	Catalog const &	catalog,
		T const &	value,
		Key< T > const &	key )

Definition at line 902 of file Catalog.h.

                                                                                    {
    return catalog.lower_bound(value, key) - catalog.begin();
}

_Catalog_upper_bound()

template<typename Catalog , typename T >

int lsst::afw::table::_Catalog_upper_bound	(	Catalog const &	catalog,
		T const &	value,
		Key< T > const &	key )

Definition at line 907 of file Catalog.h.

                                                                                    {
    return catalog.upper_bound(value, key) - catalog.begin();
}

BOOST_PP_SEQ_FOR_EACH()

lsst::afw::table::BOOST_PP_SEQ_FOR_EACH	(	INSTANTIATE_COLUMNVIEW_SCALAR	,
		_	,
		BOOST_PP_TUPLE_TO_SEQ(AFW_TABLE_SCALAR_FIELD_TYPE_N, AFW_TABLE_SCALAR_FIELD_TYPE_TUPLE)	)

calculateCoordCovariance()

Eigen::Matrix2f lsst::afw::table::calculateCoordCovariance	(	geom::SkyWcs const &	wcs,
		lsst::geom::Point2D	center,
		Eigen::Matrix2f	err )

Calculate covariance for sky coordinates.

Parameters

[in]	wcs	WCS to map from pixels to sky.
[in]	center	The object centroid.
[in]	err	Covariance matrix of the centroid.

Definition at line 95 of file wcsUtils.cc.

                                                            {
    if (!std::isfinite(center.getX()) || !std::isfinite(center.getY())) {
        return Eigen::Matrix2f::Constant(NAN);
    }
    // Get the derivative of the pixel-to-sky transformation, then use it to
    // propagate the centroid uncertainty to coordinate uncertainty. Note that
    // the calculation is done in arcseconds, then converted to radians in
    // order to achieve higher precision.
    const static double scale = 1.0 / 3600.0;
    const static Eigen::Matrix2d cdMatrix{{scale, 0}, {0, scale}};
 
    lsst::geom::SpherePoint skyCenter = wcs.pixelToSky(center);
    auto localGnomonicWcs = geom::makeSkyWcs(center, skyCenter, cdMatrix);
    auto measurementToLocalGnomonic = wcs.getTransform()->then(*localGnomonicWcs->getTransform()->inverted());
 
    Eigen::Matrix2d localMatrix = measurementToLocalGnomonic->getJacobian(center);
    Eigen::Matrix2f d = localMatrix.cast<float>() * scale * (lsst::geom::PI / 180.0);
 
    Eigen::Matrix2f skyCov = d * err * d.transpose();
 
    // Multiply by declination correction matrix in order to get sigma(RA) * cos(Dec) for the uncertainty
    // in RA, and cov(RA, Dec) * cos(Dec) for the RA/Dec covariance:
    float cosDec = std::cos(skyCenter.getDec().asRadians());
    Eigen::Matrix2f decCorr{{cosDec, 0}, {0, 1.0}};
    Eigen::Matrix2f skyCovCorr = decCorr * skyCov * decCorr;
    return skyCovCorr;
}

matchRaDec() [1/14]

template<typename Cat >

std::vector< Match< typename Cat::Record, typename Cat::Record > > lsst::afw::table::matchRaDec	(	Cat const &	cat,
		lsst::geom::Angle	radius,
		bool	symmetric )

Definition at line 239 of file Match.cc.

                                                                                           {
    MatchControl mc;
    mc.symmetricMatch = symmetric;
 
    return matchRaDec(cat, radius, mc);
}

matchRaDec() [2/14]

template<typename Cat >

std::vector< Match< typename Cat::Record, typename Cat::Record > > lsst::afw::table::matchRaDec	(	Cat const &	cat,
		lsst::geom::Angle	radius,
		MatchControl const &	mc = MatchControl() )

Parameters

cat	the catalog to self-match
radius	match radius
mc	how to do the matching (obeys MatchControl::symmetricMatch)

Definition at line 249 of file Match.cc.

                                                                                                   {
    using MatchT = Match<typename Cat::Record, typename Cat::Record>;
    std::vector<MatchT> matches;
 
    if (radius < 0.0 || radius > (45.0 * lsst::geom::degrees)) {
        throw LSST_EXCEPT(pex::exceptions::RangeError, "match radius out of range (0 to 45 degrees)");
    }
    if (cat.size() == 0) {
        return matches;
    }
    // setup match parameters
    double const d2Limit = toUnitSphereDistanceSquared(radius);
 
    // Build position list
    size_t len = cat.size();
    using Pos = RecordPos<typename Cat::Record>;
    std::unique_ptr<Pos[]> pos(new Pos[len]);
    len = makeRecordPositions(cat, pos.get());
 
    for (size_t i = 0; i < len; ++i) {
        double maxDec = pos[i].dec + radius.asRadians();
        for (size_t j = i + 1; j < len && pos[j].dec <= maxDec; ++j) {
            double dx = pos[i].x - pos[j].x;
            double dy = pos[i].y - pos[j].y;
            double dz = pos[i].z - pos[j].z;
            double d2 = dx * dx + dy * dy + dz * dz;
            if (d2 < d2Limit) {
                lsst::geom::Angle d = fromUnitSphereDistanceSquared(d2);
                matches.push_back(MatchT(pos[i].src, pos[j].src, d));
                if (mc.symmetricMatch) {
                    matches.push_back(MatchT(pos[j].src, pos[i].src, d));
                }
            }
        }
    }
    return matches;
}

matchRaDec() [3/14]

template<typename Cat1 , typename Cat2 >

std::vector< Match< typename Cat1::Record, typename Cat2::Record > > lsst::afw::table::matchRaDec	(	Cat1 const &	cat1,
		Cat2 const &	cat2,
		lsst::geom::Angle	radius,
		bool	closest )

Definition at line 147 of file Match.cc.

                                                                                           {
    MatchControl mc;
    mc.findOnlyClosest = closest;
 
    return matchRaDec(cat1, cat2, radius, mc);
}

matchRaDec() [4/14]

template<typename Cat1 , typename Cat2 >

std::vector< Match< typename Cat1::Record, typename Cat2::Record > > lsst::afw::table::matchRaDec	(	Cat1 const &	cat1,
		Cat2 const &	cat2,
		lsst::geom::Angle	radius,
		MatchControl const &	mc = MatchControl() )

Compute all tuples (s1,s2,d) where s1 belings to cat1, s2 belongs to cat2 and d, the distance between s1 and s2, is at most radius.

If cat1 and cat2 are identical, then this call is equivalent to matchRaDec(cat1,radius). The match is performed in ra, dec space.

This is instantiated for Simple-Simple, Simple-Source, and Source-Source catalog combinations.

Parameters

cat1	first catalog
cat2	second catalog
radius	match radius
mc	how to do the matching (obeys MatchControl::findOnlyClosest)

Definition at line 158 of file Match.cc.

                                                                                                     {
    using MatchT = Match<typename Cat1::Record, typename Cat2::Record>;
    std::vector<MatchT> matches;
 
    if (doSelfMatchIfSame(matches, cat1, cat2, radius)) return matches;
 
    if (radius < 0.0 || (radius > (45. * lsst::geom::degrees))) {
        throw LSST_EXCEPT(pex::exceptions::RangeError, "match radius out of range (0 to 45 degrees)");
    }
    if (cat1.size() == 0 || cat2.size() == 0) {
        return matches;
    }
    // setup match parameters
    double const d2Limit = toUnitSphereDistanceSquared(radius);
 
    // Build position lists
    size_t len1 = cat1.size();
    size_t len2 = cat2.size();
 
    using Pos1 = RecordPos<typename Cat1::Record>;
    using Pos2 = RecordPos<typename Cat2::Record>;
    std::unique_ptr<Pos1[]> pos1(new Pos1[len1]);
    std::unique_ptr<Pos2[]> pos2(new Pos2[len2]);
    len1 = makeRecordPositions(cat1, pos1.get());
    len2 = makeRecordPositions(cat2, pos2.get());
    std::shared_ptr<typename Cat2::Record> nullRecord = std::shared_ptr<typename Cat2::Record>();
 
    for (size_t i = 0, start = 0; i < len1; ++i) {
        double minDec = pos1[i].dec - radius.asRadians();
        while (start < len2 && pos2[start].dec < minDec) {
            ++start;
        }
        if (start == len2) {
            break;
        }
        double maxDec = pos1[i].dec + radius.asRadians();
        size_t closestIndex = -1;    // Index of closest match (if any)
        double d2Include = d2Limit;  // Squared distance for inclusion of match
        bool found = false;          // Found anything?
        size_t nMatches = 0;         // Number of matches
        for (size_t j = start; j < len2 && pos2[j].dec <= maxDec; ++j) {
            double dx = pos1[i].x - pos2[j].x;
            double dy = pos1[i].y - pos2[j].y;
            double dz = pos1[i].z - pos2[j].z;
            double d2 = dx * dx + dy * dy + dz * dz;
            if (d2 < d2Include) {
                if (mc.findOnlyClosest) {
                    d2Include = d2;
                    closestIndex = j;
                    found = true;
                } else {
                    matches.push_back(MatchT(pos1[i].src, pos2[j].src, fromUnitSphereDistanceSquared(d2)));
                }
                ++nMatches;
            }
        }
        if (mc.includeMismatches && nMatches == 0) {
            matches.push_back(MatchT(pos1[i].src, nullRecord, NAN));
        }
        if (mc.findOnlyClosest && found) {
            matches.push_back(
                    MatchT(pos1[i].src, pos2[closestIndex].src, fromUnitSphereDistanceSquared(d2Include)));
        }
    }
    return matches;
}

matchRaDec() [5/14]

template SimpleMatchVector lsst::afw::table::matchRaDec	(	SimpleCatalog const &	,
		lsst::geom::Angle	,
		bool	)

matchRaDec() [6/14]

template SimpleMatchVector lsst::afw::table::matchRaDec	(	SimpleCatalog const &	,
		lsst::geom::Angle	,
		MatchControl const &	)

matchRaDec() [7/14]

template SimpleMatchVector lsst::afw::table::matchRaDec	(	SimpleCatalog const &	,
		SimpleCatalog const &	,
		lsst::geom::Angle	,
		bool	)

matchRaDec() [8/14]

template SimpleMatchVector lsst::afw::table::matchRaDec	(	SimpleCatalog const &	,
		SimpleCatalog const &	,
		lsst::geom::Angle	,
		MatchControl const &	)

matchRaDec() [9/14]

template ReferenceMatchVector lsst::afw::table::matchRaDec	(	SimpleCatalog const &	,
		SourceCatalog const &	,
		lsst::geom::Angle	,
		bool	)

matchRaDec() [10/14]

template ReferenceMatchVector lsst::afw::table::matchRaDec	(	SimpleCatalog const &	,
		SourceCatalog const &	,
		lsst::geom::Angle	,
		MatchControl const &	)

matchRaDec() [11/14]

template SourceMatchVector lsst::afw::table::matchRaDec	(	SourceCatalog const &	,
		lsst::geom::Angle	,
		bool	)

matchRaDec() [12/14]

template SourceMatchVector lsst::afw::table::matchRaDec	(	SourceCatalog const &	,
		lsst::geom::Angle	,
		MatchControl const &	)

matchRaDec() [13/14]

template SourceMatchVector lsst::afw::table::matchRaDec	(	SourceCatalog const &	,
		SourceCatalog const &	,
		lsst::geom::Angle	,
		bool	)

matchRaDec() [14/14]

template SourceMatchVector lsst::afw::table::matchRaDec	(	SourceCatalog const &	,
		SourceCatalog const &	,
		lsst::geom::Angle	,
		MatchControl const &	)

matchXy() [1/4]

SourceMatchVector lsst::afw::table::matchXy	(	SourceCatalog const &	cat,
		double	radius,
		bool	symmetric )

Definition at line 383 of file Match.cc.

                                                                                   {
    MatchControl mc;
    mc.symmetricMatch = symmetric;
 
    return matchXy(cat, radius, mc);
}

matchXy() [2/4]

SourceMatchVector lsst::afw::table::matchXy	(	SourceCatalog const &	cat,
		double	radius,
		MatchControl const &	mc = MatchControl() )

Compute all tuples (s1,s2,d) where s1 != s2, s1 and s2 both belong to cat, and d, the distance between s1 and s2, in pixels, is at most radius.

The match is performed in pixel space (2d cartesian).

Parameters

cat	the catalog to self-match
radius	match radius (pixels)
mc	how to do the matching (obeys MatchControl::symmetricMatch)

Definition at line 390 of file Match.cc.

                                                                                           {
    // setup match parameters
    double const r2 = radius * radius;
 
    // copy and sort array of pointers on y
    size_t len = cat.size();
    std::unique_ptr<std::shared_ptr<SourceRecord>[]> pos(new std::shared_ptr<SourceRecord>[len]);
    size_t n = 0;
    for (SourceCatalog::const_iterator i(cat.begin()), e(cat.end()); i != e; ++i) {
        if (std::isnan(i->getX()) || std::isnan(i->getY())) {
            continue;
        }
        pos[n] = i;
        ++n;
    }
    len = n;
 
    std::sort(pos.get(), pos.get() + len, CmpRecordPtr());
 
    SourceMatchVector matches;
    for (size_t i = 0; i < len; ++i) {
        double x = pos[i]->getX();
        double y = pos[i]->getY();
        double maxY = y + radius;
        double y2;
        for (size_t j = i + 1; j < len && (y2 = pos[j]->getY()) <= maxY; ++j) {
            double dx = x - pos[j]->getX();
            double dy = y - y2;
            double d2 = dx * dx + dy * dy;
            if (d2 < r2) {
                double d = std::sqrt(d2);
                matches.push_back(SourceMatch(pos[i], pos[j], d));
                if (mc.symmetricMatch) {
                    matches.push_back(SourceMatch(pos[j], pos[i], d));
                }
            }
        }
    }
    return matches;
}

matchXy() [3/4]

SourceMatchVector lsst::afw::table::matchXy	(	SourceCatalog const &	cat1,
		SourceCatalog const &	cat2,
		double	radius,
		bool	closest )

Definition at line 298 of file Match.cc.

                                                                                                             {
    MatchControl mc;
    mc.findOnlyClosest = closest;
 
    return matchXy(cat1, cat2, radius, mc);
}

matchXy() [4/4]

SourceMatchVector lsst::afw::table::matchXy	(	SourceCatalog const &	cat1,
		SourceCatalog const &	cat2,
		double	radius,
		MatchControl const &	mc = MatchControl() )

Compute all tuples (s1,s2,d) where s1 belings to cat1, s2 belongs to cat2 and d, the distance between s1 and s2, in pixels, is at most radius.

If cat1 and cat2 are identical, then this call is equivalent to matchXy(cat1,radius). The match is performed in pixel space (2d cartesian).

Parameters

cat1	first catalog
cat2	second catalog
radius	match radius (pixels)
mc	how to do the matching (obeys MatchControl::findOnlyClosest)

Definition at line 305 of file Match.cc.

                                                  {
    if (&cat1 == &cat2) {
        return matchXy(cat1, radius);
    }
    // setup match parameters
    double const r2 = radius * radius;
 
    // copy and sort array of pointers on y
    size_t len1 = cat1.size();
    size_t len2 = cat2.size();
    std::unique_ptr<std::shared_ptr<SourceRecord>[]> pos1(new std::shared_ptr<SourceRecord>[len1]);
    std::unique_ptr<std::shared_ptr<SourceRecord>[]> pos2(new std::shared_ptr<SourceRecord>[len2]);
    std::shared_ptr<SourceRecord> nullRecord = std::shared_ptr<SourceRecord>();
    size_t n = 0;
    for (SourceCatalog::const_iterator i(cat1.begin()), e(cat1.end()); i != e; ++i) {
        if (std::isnan(i->getX()) || std::isnan(i->getY())) {
            continue;
        }
        pos1[n] = i;
        ++n;
    }
    len1 = n;
    n = 0;
    for (SourceCatalog::const_iterator i(cat2.begin()), e(cat2.end()); i != e; ++i) {
        if (std::isnan(i->getX()) || std::isnan(i->getY())) {
            continue;
        }
        pos2[n] = i;
        ++n;
    }
    len2 = n;
 
    std::sort(pos1.get(), pos1.get() + len1, CmpRecordPtr());
    std::sort(pos2.get(), pos2.get() + len2, CmpRecordPtr());
 
    SourceMatchVector matches;
    for (size_t i = 0, start = 0; i < len1; ++i) {
        double y = pos1[i]->getY();
        double minY = y - radius;
        while (start < len2 && pos2[start]->getY() < minY) {
            ++start;
        }
        if (start == len2) {
            break;
        }
        double x = pos1[i]->getX();
        double maxY = y + radius;
        double y2;
        size_t closestIndex = -1;  // Index of closest match (if any)
        double r2Include = r2;     // Squared radius for inclusion of match
        bool found = false;        // Found anything?
        size_t nMatches = 0;       // Number of matches
        for (size_t j = start; j < len2 && (y2 = pos2[j]->getY()) <= maxY; ++j) {
            double dx = x - pos2[j]->getX();
            double dy = y - y2;
            double d2 = dx * dx + dy * dy;
            if (d2 < r2Include) {
                if (mc.findOnlyClosest) {
                    r2Include = d2;
                    closestIndex = j;
                    found = true;
                } else {
                    matches.push_back(SourceMatch(pos1[i], pos2[j], std::sqrt(d2)));
                }
                ++nMatches;
            }
        }
        if (mc.includeMismatches && nMatches == 0) {
            matches.push_back(SourceMatch(pos1[i], nullRecord, NAN));
        }
        if (mc.findOnlyClosest && found) {
            matches.push_back(SourceMatch(pos1[i], pos2[closestIndex], std::sqrt(r2Include)));
        }
    }
    return matches;
}

operator<<() [1/2]

std::ostream & lsst::afw::table::operator<<	(	std::ostream &	os,
		BaseRecord const &	record )

Definition at line 158 of file BaseRecord.cc.

                                                                 {
    record._stream(os);
    return os;
}

operator<<() [2/2]

std::ostream & lsst::afw::table::operator<<	(	std::ostream &	os,
		Schema const &	schema )

Definition at line 562 of file Schema.cc.

                                                             {
    os << "Schema(\n";
    schema.forEach(Stream(&os));
    for (auto const &iter : *schema.getAliasMap()) {
        os << "    '" << iter.first << "'->'" << iter.second << "'\n";
    }
    return os << ")\n";
}

packMatches() [1/4]

template BaseCatalog lsst::afw::table::packMatches

(

ReferenceMatchVector const &

)

packMatches() [2/4]

template BaseCatalog lsst::afw::table::packMatches

(

SimpleMatchVector const &

)

packMatches() [3/4]

template BaseCatalog lsst::afw::table::packMatches

(

SourceMatchVector const &

)

packMatches() [4/4]

template<typename Record1 , typename Record2 >

BaseCatalog lsst::afw::table::packMatches

(

std::vector< Match< Record1, Record2 > > const &

matches

)

Return a table representation of a MatchVector that can be used to persist it.

The schema of the returned object has "first" (RecordId), "second" (RecordID), and "distance" (double) fields.

Parameters

[in]

matches

A std::vector of Match objects to convert to table form.

Definition at line 432 of file Match.cc.

                                                                            {
    Schema schema;
    Key<RecordId> outKey1 = schema.addField<RecordId>("first", "ID for first source record in match.");
    Key<RecordId> outKey2 = schema.addField<RecordId>("second", "ID for second source record in match.");
    Key<double> keyD = schema.addField<double>("distance", "Distance between matches sources.");
    BaseCatalog result(schema);
    result.getTable()->preallocate(matches.size());
    result.reserve(matches.size());
    using Iter = typename std::vector<Match<Record1, Record2>>::const_iterator;
    for (Iter i = matches.begin(); i != matches.end(); ++i) {
        std::shared_ptr<BaseRecord> record = result.addNew();
        record->set(outKey1, i->first->getId());
        record->set(outKey2, i->second->getId());
        record->set(keyD, i->distance);
    }
    return result;
}

PYBIND11_MODULE()

lsst::afw::table::PYBIND11_MODULE	(	_table	,
		mod	)

Definition at line 52 of file _table.cc.

                             {
    WrapperCollection wrappers(mod, "lsst.afw.table");
    wrapAliasMap(wrappers);
    wrapSchema(wrappers);
    wrapSchemaMapper(wrappers);
    wrapBaseColumnView(wrappers);
    wrapBase(wrappers);
    wrapIdFactory(wrappers);
    wrapArrays(wrappers);
    wrapAggregates(wrappers);
    wrapSlots(wrappers);
    wrapSimple(wrappers);
    wrapSource(wrappers);
    wrapExposure(wrappers);
    wrapMatch(wrappers);
    wrapWcsUtils(wrappers);
    wrappers.finish();
}

unpackMatches() [1/4]

template SimpleMatchVector lsst::afw::table::unpackMatches	(	BaseCatalog const &	,
		SimpleCatalog const &	,
		SimpleCatalog const &	)

unpackMatches() [2/4]

template ReferenceMatchVector lsst::afw::table::unpackMatches	(	BaseCatalog const &	,
		SimpleCatalog const &	,
		SourceCatalog const &	)

unpackMatches() [3/4]

template SourceMatchVector lsst::afw::table::unpackMatches	(	BaseCatalog const &	,
		SourceCatalog const &	,
		SourceCatalog const &	)

unpackMatches() [4/4]

template<typename Cat1 , typename Cat2 >

std::vector< Match< typename Cat1::Record, typename Cat2::Record > > lsst::afw::table::unpackMatches	(	BaseCatalog const &	matches,
		Cat1 const &	cat1,
		Cat2 const &	cat2 )

Reconstruct a MatchVector from a BaseCatalog representation of the matches and a pair of catalogs.

Note

The first and second catalog arguments must be sorted in ascending ID order on input; this will allow us to use binary search algorithms to find the records referred to by the match table.

If an ID cannot be found in the given tables, that pointer will be set to null in the returned match vector.

Parameters

[in]	matches	A normalized BaseCatalog representation, as produced by packMatches.
[in]	cat1	A CatalogT containing the records used on the 'first' side of the match, sorted by ascending ID.
[in]	cat2	A CatalogT containing the records used on the 'second' side of the match, sorted by ascending ID. May be the same as first.

This is instantiated for Simple-Simple, Simple-Source, and Source-Source catalog combinations.

Definition at line 455 of file Match.cc.

                                                                                                    {
    LOG_LOGGER tableLog = LOG_GET("lsst.afw.table");
    Key<RecordId> inKey1 = matches.getSchema()["first"];
    Key<RecordId> inKey2 = matches.getSchema()["second"];
    Key<double> keyD = matches.getSchema()["distance"];
    if (!first.isSorted() || !second.isSorted())
        throw LSST_EXCEPT(pex::exceptions::InvalidParameterError,
                          "Catalogs passed to unpackMatches must be sorted.");
    using MatchT = Match<typename Cat1::Record, typename Cat2::Record>;
    std::vector<MatchT> result;
    result.resize(matches.size());
    typename std::vector<MatchT>::iterator j = result.begin();
    for (BaseCatalog::const_iterator i = matches.begin(); i != matches.end(); ++i, ++j) {
        typename Cat1::const_iterator k1 = first.find(i->get(inKey1));
        typename Cat2::const_iterator k2 = second.find(i->get(inKey2));
        if (k1 != first.end()) {
            j->first = k1;
        } else {
            LOGLS_WARN(tableLog,
                       "Persisted match record with ID " << i->get(inKey1) << " not found in catalog 1.");
        }
        if (k2 != second.end()) {
            j->second = k2;
        } else {
            LOGLS_WARN(tableLog,
                       "Persisted match record with ID " << i->get(inKey2) << " not found in catalog 2.");
        }
        j->distance = i->get(keyD);
    }
    return result;
}

updateRefCentroids()

template<typename ReferenceCollection >

void lsst::afw::table::updateRefCentroids	(	geom::SkyWcs const &	wcs,
		ReferenceCollection &	refList )

Update centroids in a collection of reference objects.

Template Parameters

RefCollection

Type of sequence of reference objects, e.g. lsst::afw::table::SimpleCatalog or std::vector<std::shared_ptr<lsst::afw::table::SimpleRecord>>

Parameters

[in]	wcs	WCS to map from sky to pixels
[in,out]	refList	Collection of reference objects. The schema must have three fields: "coord": a field containing an ICRS lsst::afw::SpherePoint; this field is read "centroid": a field containing lsst::geom::Point2D; this field is written "hasCentroid": a flag; this field is written

Exceptions

lsst::pex::exceptions::NotFoundError

if refList's schema does not have the required fields.

Definition at line 73 of file wcsUtils.cc.

                                                                             {
    if (refList.empty()) {
        return;
    }
    auto const schema = getSchema(refList[0]);
    CoordKey const coordKey(schema["coord"]);
    Point2DKey const centroidKey(schema["centroid"]);
    Key<Flag> const hasCentroidKey(schema["hasCentroid"]);
    std::vector<lsst::geom::SpherePoint> skyList;
    skyList.reserve(refList.size());
    for (auto const &record : refList) {
        skyList.emplace_back(getValue(record, coordKey));
    }
    std::vector<lsst::geom::Point2D> const pixelList = wcs.skyToPixel(skyList);
    auto pixelPos = pixelList.cbegin();
    for (auto &refObj : refList) {
        setValue(refObj, centroidKey, *pixelPos);
        setValue(refObj, hasCentroidKey, true);
        ++pixelPos;
    }
}

updateSourceCoords()

template<typename SourceCollection >

void lsst::afw::table::updateSourceCoords	(	geom::SkyWcs const &	wcs,
		SourceCollection &	sourceList,
		bool	include_covariance = true )

Update sky coordinates in a collection of source objects.

Template Parameters

SourceCollection

Type of sequence of sources, e.g. lsst::afw::table::SourceCatalog or std::vector<std::shared_ptr<lsst::afw::table::SourceRecord>>

Parameters

[in]	wcs	WCS to map from pixels to sky
[in,out]	sourceList	Collection of sources. The schema must have two fields: "slot_Centroid": a field containing lsst::geom::Point2D; this field is read "coord": a field containing an ICRS lsst::afw::SpherePoint; this field is written
[in]	include_covariance	Update coordinate uncertainty using the centroid uncertainty.

Exceptions

lsst::pex::exceptions::NotFoundError

if refList's schema does not have the required fields.

Definition at line 125 of file wcsUtils.cc.

                                                                                                      {
    if (sourceList.empty()) {
        return;
    }
    auto const schema = getSchema(sourceList[0]);
    Point2DKey const centroidKey(schema["slot_Centroid"]);
    CovarianceMatrixKey<float, 2> const centroidErrKey(schema["slot_Centroid"], {"x", "y"});
    CoordKey const coordKey(schema["coord"]);
    std::vector<lsst::geom::Point2D> pixelList;
    pixelList.reserve(sourceList.size());
    std::vector<Eigen::Matrix2f> skyErrList;
    skyErrList.reserve(sourceList.size());
 
    for (auto const &source : sourceList) {
        lsst::geom::Point2D center = getValue(source, centroidKey);
        pixelList.emplace_back(center);
        if (include_covariance) {
            auto err = getValue(source, centroidErrKey);
            Eigen::Matrix2f skyCov = calculateCoordCovariance(wcs, center, err);
            skyErrList.emplace_back(skyCov);
        }
    }
 
    std::vector<lsst::geom::SpherePoint> const skyList = wcs.pixelToSky(pixelList);
    auto skyCoord = skyList.cbegin();
    auto skyErr = skyErrList.cbegin();
    for (auto &source : sourceList) {
        setValue(source, coordKey, *skyCoord);
        if (include_covariance) {
            CoordKey::ErrorKey const coordErrKey = CoordKey::getErrorKey(schema);
            setValue(source, coordErrKey, *skyErr);
        }
        ++skyCoord;
        ++skyErr;
    }
}

wrapAggregates()

void lsst::afw::table::wrapAggregates

(

WrapperCollection &

wrappers

)

Definition at line 225 of file _aggregates.cc.

                                                 {
    // TODO: uncomment once afw.geom uses WrapperCollection
    // wrappers.addSignatureDependency("lsst.afw.geom.ellipses");
 
    wrappers.wrapType(py::enum_<CoordinateType>(wrappers.module, "CoordinateType"), [](auto &mod, auto &enm) {
        enm.value("PIXEL", CoordinateType::PIXEL);
        enm.value("CELESTIAL", CoordinateType::CELESTIAL);
        enm.export_values();
    });
 
    declarePointKey<double>(wrappers, "2D");
    declarePointKey<int>(wrappers, "2I");
    declarePoint3Key<double>(wrappers, "D");
    declarePoint3Key<int>(wrappers, "I");
 
    declareBoxKey<lsst::geom::Box2D>(wrappers, "2D");
    declareBoxKey<lsst::geom::Box2I>(wrappers, "2I");
 
    declareCoordKey(wrappers);
    declareQuadrupoleKey(wrappers);
    declareEllipseKey(wrappers);
 
    declareCovarianceMatrixKey<float, 2>(wrappers, "2f");
    declareCovarianceMatrixKey<float, 3>(wrappers, "3f");
    declareCovarianceMatrixKey<float, 4>(wrappers, "4f");
    declareCovarianceMatrixKey<float, Eigen::Dynamic>(wrappers, "Xf");
    declareCovarianceMatrixKey<double, 2>(wrappers, "2d");
    declareCovarianceMatrixKey<double, 3>(wrappers, "3d");
    declareCovarianceMatrixKey<double, 4>(wrappers, "4d");
    declareCovarianceMatrixKey<double, Eigen::Dynamic>(wrappers, "Xd");
}

wrapAliasMap()

void lsst::afw::table::wrapAliasMap

(

cpputils::python::WrapperCollection &

wrappers

)

Definition at line 39 of file _aliasMap.cc.

                                                             {
    wrappers.wrapType(PyAliasMap(wrappers.module, "AliasMap"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        cls.def(py::init<AliasMap const &>());
 
        cls.def("__len__", &AliasMap::size);
        cls.def("empty", &AliasMap::empty);
        cls.def("apply", &AliasMap::apply, "name"_a);
        cls.def("get", &AliasMap::get, "alias"_a);
        cls.def("__getitem__", &AliasMap::get, "alias"_a);
        cls.def("set", &AliasMap::set, "alias"_a, "target"_a);
        cls.def("__setitem__", &AliasMap::set);
        cls.def("erase", &AliasMap::erase, "alias"_a);
        cls.def("__delitem__", &AliasMap::erase, "alias"_a);
        cls.def("__eq__", [](AliasMap &self, AliasMap &other) { return self == other; });
        cls.def("__ne__", [](AliasMap &self, AliasMap &other) { return self != other; });
        cls.def("contains", &AliasMap::contains, "other"_a);
        cls.def("__contains__", &AliasMap::contains);
        cls.def("items", [](AliasMap &self) { return py::make_iterator(self.begin(), self.end()); },
                py::keep_alive<0, 1>());
    });
}

wrapArrays()

void lsst::afw::table::wrapArrays

(

WrapperCollection &

wrappers

)

Definition at line 101 of file _arrays.cc.

                                             {
    declareArrayKey<float>(wrappers, "F");
    declareArrayKey<double>(wrappers, "D");
}

wrapBase()

void lsst::afw::table::wrapBase

(

WrapperCollection &

wrappers

)

Definition at line 175 of file _base.cc.

                                           {
    wrappers.addSignatureDependency("lsst.daf.base");
 
    auto clsBaseTable = declareBaseTable(wrappers);
    auto clsBaseRecord = declareBaseRecord(wrappers);
    auto clsBaseCatalog = table::python::declareCatalog<BaseRecord>(wrappers, "Base");
    auto clsBaseColumnView = table::python::declareColumnView<BaseRecord>(wrappers, "Base");
 
    clsBaseRecord.attr("Table") = clsBaseTable;
    clsBaseRecord.attr("ColumnView") = clsBaseColumnView;
    clsBaseRecord.attr("Catalog") = clsBaseCatalog;
    clsBaseTable.attr("Record") = clsBaseRecord;
    clsBaseTable.attr("ColumnView") = clsBaseColumnView;
    clsBaseTable.attr("Catalog") = clsBaseCatalog;
    clsBaseCatalog.attr("Record") = clsBaseRecord;
    clsBaseCatalog.attr("Table") = clsBaseTable;
    clsBaseCatalog.attr("ColumnView") = clsBaseColumnView;
}

wrapBaseColumnView()

void lsst::afw::table::wrapBaseColumnView

(

WrapperCollection &

wrappers

)

Definition at line 128 of file _baseColumnView.cc.

                                                     {
    declareBaseColumnView(wrappers);
    declareBitsColumn(wrappers);
}

wrapExposure()

void lsst::afw::table::wrapExposure

(

WrapperCollection &

wrappers

)

Definition at line 176 of file _exposure.cc.

                                               {
    // wrappers.addSignatureDependency("lsst.afw.geom");
    // TODO: afw.geom, afw.image, and afw.detection cannot be imported due to
    // circular dependencies until at least afw.image uses WrapperCollection
    // in DM-20703
 
    auto clsExposureRecord = declareExposureRecord(wrappers);
    auto clsExposureTable = declareExposureTable(wrappers);
    auto clsExposureColumnView = table::python::declareColumnView<ExposureRecord>(wrappers, "Exposure");
    auto clsExposureCatalog = declareExposureCatalog(wrappers);
 
    clsExposureRecord.attr("Table") = clsExposureTable;
    clsExposureRecord.attr("ColumnView") = clsExposureColumnView;
    clsExposureRecord.attr("Catalog") = clsExposureCatalog;
    clsExposureTable.attr("Record") = clsExposureRecord;
    clsExposureTable.attr("ColumnView") = clsExposureColumnView;
    clsExposureTable.attr("Catalog") = clsExposureCatalog;
    clsExposureCatalog.attr("Record") = clsExposureRecord;
    clsExposureCatalog.attr("Table") = clsExposureTable;
    clsExposureCatalog.attr("ColumnView") = clsExposureColumnView;
}

wrapIdFactory()

void lsst::afw::table::wrapIdFactory

(

cpputils::python::WrapperCollection &

wrappers

)

Definition at line 38 of file _idFactory.cc.

                                                              {
    wrappers.wrapType(PyIdFactory(wrappers.module, "IdFactory"), [](auto& mod, auto& cls) {
        cls.def("__call__", &IdFactory::operator());
        cls.def("notify", &IdFactory::notify, "id"_a);
        cls.def("clone", &IdFactory::clone);
        cls.def_static("makeSimple", IdFactory::makeSimple);
        cls.def_static("makeSource", IdFactory::makeSource, "expId"_a, "reserved"_a);
        cls.def_static("computeReservedFromMaxBits", IdFactory::computeReservedFromMaxBits, "maxBits"_a);
    });
}

wrapMatch()

void lsst::afw::table::wrapMatch

(

WrapperCollection &

wrappers

)

Definition at line 89 of file _match.cc.

                                            {
    wrappers.wrapType(py::class_<MatchControl>(wrappers.module, "MatchControl"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        LSST_DECLARE_CONTROL_FIELD(cls, MatchControl, findOnlyClosest);
        LSST_DECLARE_CONTROL_FIELD(cls, MatchControl, symmetricMatch);
        LSST_DECLARE_CONTROL_FIELD(cls, MatchControl, includeMismatches);
    });
 
    declareMatch2<SimpleCatalog, SimpleCatalog>(wrappers, "Simple");
    declareMatch2<SimpleCatalog, SourceCatalog>(wrappers, "Reference");
    declareMatch2<SourceCatalog, SourceCatalog>(wrappers, "Source");
    declareMatch1<SimpleCatalog>(wrappers);
    declareMatch1<SourceCatalog>(wrappers);
 
    wrappers.wrap([](auto &mod) {
        mod.def("matchXy",
                (SourceMatchVector(*)(SourceCatalog const &, SourceCatalog const &, double,
                                      MatchControl const &))matchXy,
                "cat1"_a, "cat2"_a, "radius"_a, "mc"_a = MatchControl());
        mod.def("matchXy", (SourceMatchVector(*)(SourceCatalog const &, double, MatchControl const &))matchXy,
                "cat"_a, "radius"_a, "mc"_a = MatchControl());
    });
}

wrapSchema()

void lsst::afw::table::wrapSchema

(

WrapperCollection &

wrappers

)

Definition at line 539 of file _schema.cc.

                                             {
    // We'll add instantiations of Field, Key, and SchemaItem to these private
    // dicts, and then in schemaContinued.py we'll add them to a TemplateMeta
    // ABC.
    auto &mod = wrappers.module;
    mod.attr("_Field") = py::dict();
    mod.attr("_Key") = py::dict();
    mod.attr("_SchemaItem") = py::dict();
 
    declareSchemaType<std::uint8_t>(wrappers);
    declareSchemaType<std::uint16_t>(wrappers);
    declareSchemaType<std::int32_t>(wrappers);
    declareSchemaType<std::int64_t>(wrappers);
    declareSchemaType<float>(wrappers);
    declareSchemaType<double>(wrappers);
    declareSchemaType<std::string>(wrappers);
    declareSchemaType<lsst::geom::Angle>(wrappers);
    declareSchemaType<Array<std::uint8_t>>(wrappers);
    declareSchemaType<Array<std::uint16_t>>(wrappers);
    declareSchemaType<Array<int>>(wrappers);
    declareSchemaType<Array<float>>(wrappers);
    declareSchemaType<Array<double>>(wrappers);
    declareSchemaType<Flag>(wrappers);
 
    declareSchema(wrappers);
    declareSubSchema(wrappers);
}

wrapSchemaMapper()

void lsst::afw::table::wrapSchemaMapper

(

WrapperCollection &

wrappers

)

Definition at line 55 of file _schemaMapper.cc.

                                                   {
    wrappers.wrapType(PySchemaMapper(wrappers.module, "SchemaMapper"), [](auto &mod, auto &cls) {
        cls.def(py::init<>());
        cls.def(py::init<Schema const &, Schema const &>());
        cls.def(py::init<Schema const &, bool>(), "input"_a, "shareAliasMap"_a = false);
 
        cls.def("getInputSchema", &SchemaMapper::getInputSchema);
        cls.def("getOutputSchema", &SchemaMapper::getOutputSchema);
        cls.def("editOutputSchema", &SchemaMapper::editOutputSchema,
                py::return_value_policy::reference_internal);
        cls.def("addMinimalSchema", &SchemaMapper::addMinimalSchema, "minimal"_a, "doMap"_a = true);
        cls.def_static("removeMinimalSchema", &SchemaMapper::removeMinimalSchema);
        cls.def_static("join", &SchemaMapper::join, "inputs"_a, "prefixes"_a = std::vector<std::string>());
 
        declareSchemaMapperOverloads<std::uint8_t>(cls, "B");
        declareSchemaMapperOverloads<std::uint16_t>(cls, "U");
        declareSchemaMapperOverloads<std::int32_t>(cls, "I");
        declareSchemaMapperOverloads<std::int64_t>(cls, "L");
        declareSchemaMapperOverloads<float>(cls, "F");
        declareSchemaMapperOverloads<double>(cls, "D");
        declareSchemaMapperOverloads<std::string>(cls, "String");
        declareSchemaMapperOverloads<lsst::geom::Angle>(cls, "Angle");
        declareSchemaMapperOverloads<lsst::afw::table::Flag>(cls, "Flag");
        declareSchemaMapperOverloads<lsst::afw::table::Array<std::uint8_t>>(cls, "ArrayB");
        declareSchemaMapperOverloads<lsst::afw::table::Array<std::uint16_t>>(cls, "ArrayU");
        declareSchemaMapperOverloads<lsst::afw::table::Array<int>>(cls, "ArrayI");
        declareSchemaMapperOverloads<lsst::afw::table::Array<float>>(cls, "ArrayF");
        declareSchemaMapperOverloads<lsst::afw::table::Array<double>>(cls, "ArrayD");
    });
}

wrapSimple()

void lsst::afw::table::wrapSimple

(

WrapperCollection &

wrappers

)

Definition at line 92 of file _simple.cc.

                                             {
    auto clsSimpleRecord = declareSimpleRecord(wrappers);
    auto clsSimpleTable = declareSimpleTable(wrappers);
    auto clsSimpleColumnView = table::python::declareColumnView<SimpleRecord>(wrappers, "Simple");
    auto clsSimpleCatalog = table::python::declareSortedCatalog<SimpleRecord>(wrappers, "Simple");
 
    clsSimpleRecord.attr("Table") = clsSimpleTable;
    clsSimpleRecord.attr("ColumnView") = clsSimpleColumnView;
    clsSimpleRecord.attr("Catalog") = clsSimpleCatalog;
    clsSimpleTable.attr("Record") = clsSimpleRecord;
    clsSimpleTable.attr("ColumnView") = clsSimpleColumnView;
    clsSimpleTable.attr("Catalog") = clsSimpleCatalog;
    clsSimpleCatalog.attr("Record") = clsSimpleRecord;
    clsSimpleCatalog.attr("Table") = clsSimpleTable;
    clsSimpleCatalog.attr("ColumnView") = clsSimpleColumnView;
}

wrapSlots()

void lsst::afw::table::wrapSlots

(

WrapperCollection &

wrappers

)

Definition at line 70 of file _slots.cc.

                                            {
    // TODO: uncomment once afw.geom uses WrapperCollection
    // wrappers.addSignatureDependency("lsst.afw.geom.ellipses");
 
    declareSlotDefinition(wrappers);
    declareSlotDefinitionSubclass<FluxSlotDefinition>(wrappers, "Flux");
    declareSlotDefinitionSubclass<CentroidSlotDefinition>(wrappers, "Centroid");
    declareSlotDefinitionSubclass<ShapeSlotDefinition>(wrappers, "Shape");
}

wrapSource()

void lsst::afw::table::wrapSource

(

WrapperCollection &

wrappers

)

Definition at line 182 of file _source.cc.

                                             {
    // TODO: uncomment once afw.geom uses WrapperCollection
    // wrappers.addSignatureDependency("lsst.afw.geom.ellipses");
 
    // SourceFitsFlags enum values are used as integer masks, so wrap as attributes instead of an enum
    // static_cast is required to avoid an import error (py::cast and py::int_ do not work by themselves
    // and are not required with the static_cast)
    auto &mod = wrappers.module;
    mod.attr("SOURCE_IO_NO_FOOTPRINTS") = static_cast<int>(SourceFitsFlags::SOURCE_IO_NO_FOOTPRINTS);
    mod.attr("SOURCE_IO_NO_HEAVY_FOOTPRINTS") =
            static_cast<int>(SourceFitsFlags::SOURCE_IO_NO_HEAVY_FOOTPRINTS);
 
    auto clsSourceRecord = declareSourceRecord(wrappers);
    auto clsSourceTable = declareSourceTable(wrappers);
    auto clsSourceColumnView = declareSourceColumnView(wrappers);
    auto clsSourceCatalog = table::python::declareSortedCatalog<SourceRecord>(wrappers, "Source");
 
    clsSourceRecord.attr("Table") = clsSourceTable;
    clsSourceRecord.attr("ColumnView") = clsSourceColumnView;
    clsSourceRecord.attr("Catalog") = clsSourceCatalog;
    clsSourceTable.attr("Record") = clsSourceRecord;
    clsSourceTable.attr("ColumnView") = clsSourceColumnView;
    clsSourceTable.attr("Catalog") = clsSourceCatalog;
    clsSourceCatalog.attr("Record") = clsSourceRecord;
    clsSourceCatalog.attr("Table") = clsSourceTable;
    clsSourceCatalog.attr("ColumnView") = clsSourceColumnView;
}

wrapWcsUtils()

void lsst::afw::table::wrapWcsUtils

(

WrapperCollection &

wrappers

)

Definition at line 65 of file _wcsUtils.cc.

                                               {
    declareUpdateRefCentroids<std::vector<std::shared_ptr<lsst::afw::table::SimpleRecord>>>(wrappers);
    declareUpdateRefCentroids<lsst::afw::table::SimpleCatalog>(wrappers);
 
    declareUpdateSourceCoords<std::vector<std::shared_ptr<lsst::afw::table::SourceRecord>>>(wrappers);
    declareUpdateSourceCoords<lsst::afw::table::SourceCatalog>(wrappers);
}

Variable Documentation

_

lsst::afw::table::_

Definition at line 198 of file BaseColumnView.cc.