Namespaces
	_aggregates

	_aliasMap

	_arrays

	_base

	_baseColumnView

	_exposure

	_match

	_schema

	_schemaMapper

	_simple

	_source

	catalogMatches

	detail

	io

	multiMatch

	python

	testUtils

Classes
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	BoxKey
	A FunctorKey used to get or set a lsst::geom::Box2I or Box2D from a (min, max) pair of PointKeys. More...

class	CoordKey
	A FunctorKey used to get or set celestial coordinates from a pair of lsst::geom::Angle keys. More...

class	QuadrupoleKey
	A FunctorKey used to get or set a geom::ellipses::Quadrupole from a tuple of constituent Keys. More...

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	CovarianceMatrixKey

class	AliasMap
	Mapping class that holds aliases for a Schema. More...

class	ArrayKey
	A FunctorKey used to get or set a ndarray::Array from a sequence of scalar Keys. More...

class	BitsColumn
	A packed representation of a collection of Flag field columns. More...

class	BaseColumnView
	Column-wise view into a sequence of records that have been allocated contiguously. More...

class	ColumnViewT

class	BaseRecord
	Base class for all records. More...

class	BaseTable
	Base class for all tables. More...

class	CatalogIterator
	Iterator class for CatalogT. More...

class	CatalogT
	A custom container class for records, based on std::vector. 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	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< std::string >
	Field base class specialization for strings. More...

struct	FieldBase< Flag >
	Specialization for Flag fields. More...

class	KeyBase< Flag >
	A base class for Key that allows the underlying storage field to be extracted. More...

class	Key< Flag >
	Key specialization for Flag. More...

class	OutputFunctorKey
	Base class for objects that can extract a value from a record, but are not a true Key themselves. More...

class	InputFunctorKey
	Base class for objects that can set a value on a record, but are not a true Key themselves. More...

class	FunctorKey
	Convenience base class that combines the OutputFunctorKey and InputFunctorKey. 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	ConstReferenceFunctorKey
	Base class for objects that can return a const reference to part of a record, but are not a true Key. More...

class	Key
	A class used as a handle to a particular field in a table. 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

struct	Match
	Lightweight representation of a geometric match between two records. More...

class	IdFactory
	A polymorphic functor base class for generating record IDs for a table. 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	MatchControl
	Pass parameters to algorithms that match list of sources. More...

class	Array
	Tag types used to declare specialized field types. More...

class	Schema
	Defines the fields and offsets for a table. More...

class	SubSchema
	A proxy type for name lookups in a Schema. More...

class	SchemaMapper
	A mapping between the keys of two Schemas, used to copy data between them. 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...

class	FluxSlotDefinition
	SlotDefinition specialization for fluxes. More...

class	CentroidSlotDefinition
	SlotDefinition specialization for centroids. More...

class	ShapeSlotDefinition
	SlotDefinition specialization for shapes. More...

struct	SlotSuite
	An aggregate containing all of the current slots used in SourceTable. More...

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	PersistableObjectColumnReader

Typedefs
typedef PointKey< int >	Point2IKey

typedef PointKey< double >	Point2DKey

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

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

typedef ColumnViewT< ExposureRecord >	ExposureColumnView

typedef ExposureCatalogT< ExposureRecord >	ExposureCatalog

typedef ExposureCatalogT< ExposureRecord const >	ConstExposureCatalog

typedef CatalogT< BaseRecord >	BaseCatalog

typedef CatalogT< BaseRecord const >	ConstBaseCatalog

typedef ColumnViewT< SimpleRecord >	SimpleColumnView

typedef SortedCatalogT< SimpleRecord >	SimpleCatalog

typedef SortedCatalogT< SimpleRecord const >	ConstSimpleCatalog

typedef SourceColumnViewT< SourceRecord >	SourceColumnView

typedef SortedCatalogT< SourceRecord >	SourceCatalog

typedef SortedCatalogT< SourceRecord const >	ConstSourceCatalog

typedef ColumnViewT< AmpInfoRecord >	AmpInfoColumnView

typedef CatalogT< AmpInfoRecord >	AmpInfoCatalog

typedef CatalogT< AmpInfoRecord const >	ConstAmpInfoCatalog

typedef Match< SimpleRecord, SimpleRecord >	SimpleMatch

typedef Match< SimpleRecord, SourceRecord >	ReferenceMatch

typedef Match< SourceRecord, SourceRecord >	SourceMatch

typedef std::vector< SimpleMatch >	SimpleMatchVector

typedef std::vector< ReferenceMatch >	ReferenceMatchVector

typedef std::vector< SourceMatch >	SourceMatchVector

typedef std::int64_t	RecordId
	Type used for unique IDs for records. More...

typedef lsst::geom::Angle	Angle

typedef lsst::geom::SpherePoint	SpherePoint

typedef lsst::afw::detection::Footprint	Footprint

typedef boost::mpl::vector< RecordId, std::uint16_t, std::int32_t, float, double, lsst::geom::Angle, std::uint8_t >	ScalarFieldTypes
	An MPL vector of scalar field types. More...

typedef boost::mpl::vector< 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 > >	FieldTypes
	An MPL vector of all field types. More...

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`. More...

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`. More...

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`. More...

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

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

template<typename ReferenceCollection >
void	updateRefCentroids (geom::SkyWcs const &wcs, ReferenceCollection &refList)
	Update centroids in a collection of reference objects. More...

template<typename SourceCollection >
void	updateSourceCoords (geom::SkyWcs const &wcs, SourceCollection &sourceList)
	Update sky coordinates in a collection of source objects. More...

void	wrapAggregates (WrapperCollection &wrappers)

void	wrapAliasMap (utils::python::WrapperCollection &wrappers)

void	wrapArrays (WrapperCollection &wrappers)

void	wrapBase (WrapperCollection &wrappers)

void	wrapBaseColumnView (WrapperCollection &wrappers)

void	wrapExposure (WrapperCollection &wrappers)

void	wrapIdFactory (utils::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

typedef CatalogT<AmpInfoRecord> lsst::afw::table::AmpInfoCatalog

Definition at line 97 of file fwd.h.

◆ AmpInfoColumnView

typedef ColumnViewT<AmpInfoRecord> lsst::afw::table::AmpInfoColumnView

Definition at line 96 of file fwd.h.

◆ Angle

typedef lsst::geom::Angle lsst::afw::table::Angle

Definition at line 34 of file misc.h.

◆ BaseCatalog

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

Definition at line 72 of file fwd.h.

◆ Box2DKey

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

Definition at line 202 of file aggregates.h.

◆ Box2IKey

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

Definition at line 201 of file aggregates.h.

◆ ConstAmpInfoCatalog

typedef CatalogT<AmpInfoRecord const> lsst::afw::table::ConstAmpInfoCatalog

Definition at line 98 of file fwd.h.

◆ ConstBaseCatalog

typedef CatalogT<BaseRecord const> lsst::afw::table::ConstBaseCatalog

Definition at line 73 of file fwd.h.

◆ ConstExposureCatalog

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

Definition at line 490 of file Exposure.h.

◆ ConstSimpleCatalog

typedef SortedCatalogT<SimpleRecord const> lsst::afw::table::ConstSimpleCatalog

Definition at line 80 of file fwd.h.

◆ ConstSourceCatalog

typedef SortedCatalogT<SourceRecord const> lsst::afw::table::ConstSourceCatalog

Definition at line 86 of file fwd.h.

◆ ExposureCatalog

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

Definition at line 489 of file Exposure.h.

◆ ExposureColumnView

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

Definition at line 488 of file Exposure.h.

◆ FieldTypes

typedef boost::mpl::vector< 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> > lsst::afw::table::FieldTypes

An MPL vector of all field types.

Definition at line 54 of file types.h.

◆ Footprint

typedef lsst::afw::detection::Footprint lsst::afw::table::Footprint

Definition at line 59 of file Source.h.

◆ Point2DKey

typedef PointKey<double> lsst::afw::table::Point2DKey

Definition at line 118 of file aggregates.h.

◆ Point2IKey

typedef PointKey<int> lsst::afw::table::Point2IKey

Definition at line 117 of file aggregates.h.

◆ PyAliasMap

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

Definition at line 37 of file _aliasMap.cc.

◆ PyIdFactory

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

Definition at line 36 of file _idFactory.cc.

◆ PySchemaMapper

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

Definition at line 43 of file _schemaMapper.cc.

◆ RecordId

typedef std::int64_t lsst::afw::table::RecordId

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 22 of file misc.h.

◆ ReferenceMatch

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

Definition at line 104 of file fwd.h.

◆ ReferenceMatchVector

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

Definition at line 108 of file fwd.h.

◆ ScalarFieldTypes

typedef boost::mpl::vector< RecordId, std::uint16_t, std::int32_t, float, double, lsst::geom::Angle, std::uint8_t > lsst::afw::table::ScalarFieldTypes

An MPL vector of scalar field types.

Definition at line 51 of file types.h.

◆ SimpleCatalog

typedef SortedCatalogT<SimpleRecord> lsst::afw::table::SimpleCatalog

Definition at line 79 of file fwd.h.

◆ SimpleColumnView

typedef ColumnViewT<SimpleRecord> lsst::afw::table::SimpleColumnView

Definition at line 78 of file fwd.h.

◆ SimpleMatch

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

Definition at line 103 of file fwd.h.

◆ SimpleMatchVector

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

Definition at line 107 of file fwd.h.

◆ SourceCatalog

typedef SortedCatalogT<SourceRecord> lsst::afw::table::SourceCatalog

Definition at line 85 of file fwd.h.

◆ SourceColumnView

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

Definition at line 84 of file fwd.h.

◆ SourceMatch

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

Definition at line 105 of file fwd.h.

◆ SourceMatchVector

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

Definition at line 109 of file fwd.h.

◆ SpherePoint

typedef lsst::geom::SpherePoint lsst::afw::table::SpherePoint

Definition at line 35 of file misc.h.

Enumeration Type Documentation

◆ CoordinateType

enum lsst::afw::table::CoordinateType

strong

Enum used to set units for geometric FunctorKeys.

Enumerator
PIXEL
CELESTIAL

Definition at line 277 of file aggregates.h.

277 { PIXEL, CELESTIAL };

lsst::afw::table::CoordinateType::PIXEL

@ PIXEL

lsst::afw::table::CoordinateType::CELESTIAL

@ 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 54 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 890 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 871 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 880 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 885 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)
	)

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

                                                                                                    {
     typedef Match<typename Cat::Record, typename Cat::Record> MatchT;
     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();
     typedef RecordPos<typename Cat::Record> Pos;
     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.

                                                                                                      {
     typedef Match<typename Cat1::Record, typename Cat2::Record> MatchT;
     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();
  
     typedef RecordPos<typename Cat1::Record> Pos1;
     typedef RecordPos<typename Cat2::Record> Pos2;
     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 159 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 751 of file Schema.cc.

                                                              {
     os << "Schema(\n";
     schema.forEach(Stream(&os));
     for (auto iter = schema.getAliasMap()->begin(); iter != schema.getAliasMap()->end(); ++iter) {
         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());
     typedef typename std::vector<Match<Record1, Record2> >::const_iterator Iter;
     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("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.");
     typedef Match<typename Cat1::Record, typename Cat2::Record> MatchT;
     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
	)

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

Exceptions

lsst::pex::exceptions::NotFoundError if refList's schema does not have the required fields.

Definition at line 96 of file wcsUtils.cc.

                                                                              {
     if (sourceList.empty()) {
         return;
     }
     auto const schema = getSchema(sourceList[0]);
     Point2DKey const centroidKey(schema["slot_Centroid"]);
     CoordKey const coordKey(schema["coord"]);
     std::vector<lsst::geom::Point2D> pixelList;
     pixelList.reserve(sourceList.size());
     for (auto const &source : sourceList) {
         pixelList.emplace_back(getValue(source, centroidKey));
     }
     std::vector<lsst::geom::SpherePoint> const skyList = wcs.pixelToSky(pixelList);
     auto skyCoord = skyList.cbegin();
     for (auto &source : sourceList) {
         setValue(source, coordKey, *skyCoord);
         ++skyCoord;
     }
 }

◆ wrapAggregates()

void lsst::afw::table::wrapAggregates ( WrapperCollection & wrappers )

Definition at line 201 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");
  
     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 ( utils::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 174 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 175 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 ( utils::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 540 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 64 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 188 of file BaseColumnView.cc.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AmpInfoCatalog

◆ AmpInfoColumnView

◆ Angle

◆ BaseCatalog

◆ Box2DKey

◆ Box2IKey

◆ ConstAmpInfoCatalog

◆ ConstBaseCatalog

◆ ConstExposureCatalog

◆ ConstSimpleCatalog

◆ ConstSourceCatalog

◆ ExposureCatalog

◆ ExposureColumnView

◆ FieldTypes

◆ Footprint

◆ Point2DKey

◆ Point2IKey

◆ PyAliasMap

◆ PyIdFactory

◆ PySchemaMapper

◆ RecordId

◆ ReferenceMatch

◆ ReferenceMatchVector

◆ ScalarFieldTypes

◆ SimpleCatalog

◆ SimpleColumnView

◆ SimpleMatch

◆ SimpleMatchVector

◆ SourceCatalog

◆ SourceColumnView

◆ SourceMatch

◆ SourceMatchVector

◆ SpherePoint

Enumeration Type Documentation

◆ CoordinateType

◆ SourceFitsFlags

Function Documentation

◆ _Catalog_equal_range()

◆ _Catalog_find()

◆ _Catalog_lower_bound()

◆ _Catalog_upper_bound()

◆ BOOST_PP_SEQ_FOR_EACH()

◆ matchRaDec() [1/14]

◆ matchRaDec() [2/14]

◆ matchRaDec() [3/14]

◆ matchRaDec() [4/14]

◆ matchRaDec() [5/14]

◆ matchRaDec() [6/14]

◆ matchRaDec() [7/14]

◆ matchRaDec() [8/14]

◆ matchRaDec() [9/14]

◆ matchRaDec() [10/14]

◆ matchRaDec() [11/14]

◆ matchRaDec() [12/14]

◆ matchRaDec() [13/14]

◆ matchRaDec() [14/14]

◆ matchXy() [1/4]

◆ matchXy() [2/4]

◆ matchXy() [3/4]

◆ matchXy() [4/4]

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ packMatches() [1/4]

◆ packMatches() [2/4]

◆ packMatches() [3/4]

◆ packMatches() [4/4]

◆ PYBIND11_MODULE()

◆ unpackMatches() [1/4]

◆ unpackMatches() [2/4]

◆ unpackMatches() [3/4]

◆ unpackMatches() [4/4]

◆ updateRefCentroids()

◆ updateSourceCoords()