lsst::ap::EllipseList< DataT > Class Template Reference

A list of ellipses, implemented using std::vector. More...

#include <EllipseTypes.h>

Inheritance diagram for lsst::ap::EllipseList< DataT >:

Public Member Functions
	EllipseList ()
	EllipseList (DataT *const begin, DataT *const end)
void	prepareForMatch (ZoneStripeChunkDecomposition const &zsc)

Additional Inherited Members
Public Attributes inherited from std::vector< T >
T	elements
	STL member. More...

Detailed Description

template<typename DataT>
class lsst::ap::EllipseList< DataT >

A list of ellipses, implemented using std::vector.

Supports the in-ellipse cross matching algorithms.

Definition at line 141 of file EllipseTypes.h.

Constructor & Destructor Documentation

template<typename DataT>

lsst::ap::EllipseList< DataT >::EllipseList ( )

inline

Definition at line 143 of file EllipseTypes.h.

: std::vector<Ellipse<DataT> >() {}

template<typename DataT >

lsst::ap::EllipseList< DataT >::EllipseList	(	DataT *const	begin,
		DataT *const	end
	)

Creates a list of ellipses from the given data objects.

Definition at line 81 of file EllipseTypes.cc.

    : std::vector<Ellipse<DataT> >()
{
    std::ptrdiff_t const n = end - begin;
    for (std::ptrdiff_t i = 0; i < n; ++i) {
        push_back(Ellipse<DataT>(begin[i]));
    }
}

Member Function Documentation

template<typename DataT >

void lsst::ap::EllipseList< DataT >::prepareForMatch

(

ZoneStripeChunkDecomposition const &

zsc

)

Prepares the list of ellipses for matching against a list of positions – finds zone bounds for each ellipse and sorts them in order of minimum zone.

Definition at line 95 of file EllipseTypes.cc.

                                                                                       {
    typedef typename std::vector<DataT>::size_type size_type; 
    size_type const sz = this->size();

    // find min and max zone for each ellipse
    for (size_type i = 0; i < sz; ++i) {
        Ellipse<DataT> & e = this->operator[](i);
        double dec  = e._data->getDec();
        double smaa = e._data->getSemiMajorAxisLength();
        // Note - this actually computes the min/max zone of the ellipses bounding circle
        double d = dec - smaa;
        e._minZone = zsc.decToZone(d <= -90.0 ? -90.0 : d);
        d = dec + smaa;
        e._maxZone = zsc.decToZone(d >= 90.0 ? 90.0 : d);
        e._next = 0;
    }

    if (sz > 1) {
        // indirect sort on min zone
        boost::scoped_array<Ellipse<DataT> *> pointers(new Ellipse<DataT> *[sz]);
        for (size_type i = 0; i < sz; ++i) {
            pointers[i] = &this->operator[](i);
        }
        std::sort(pointers.get(), pointers.get() + sz, EllipsePtrLessThan<DataT>());
        // copy ellipses into new array in sorted order
        std::vector<Ellipse<DataT> > ellipses;
        ellipses.reserve(sz);
        for (size_type i = 0; i < sz; ++i) {
            ellipses.push_back(*pointers[i]);
        }
        // replace old array with new sorted one
        this->swap(ellipses);
    }
}

---

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

• /home/lsstsw/stack/Linux64/ap/10.0+224/include/lsst/ap/EllipseTypes.h
• /home/lsstsw/stack/Linux64/ap/10.0+224/include/lsst/ap/EllipseTypes.cc