aggregates.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2014 LSST Corporation.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef AFW_TABLE_aggregates_h_INCLUDED
#define AFW_TABLE_aggregates_h_INCLUDED

#include "lsst/afw/table/FunctorKey.h"
#include "lsst/afw/table/Schema.h"

namespace lsst { namespace afw {

namespace geom {

template <typename T, int N> class Point;

namespace ellipses {

class Quadrupole;

} // namespace ellipses
} // namespace geom

namespace table {

template <typename T>
class PointKey : public FunctorKey< lsst::afw::geom::Point<T,2> > {
public:

    static PointKey addFields(
        Schema & schema,
        std::string const & name,
        std::string const & doc,
        std::string const & unit
    );

    PointKey() : _x(), _y() {}

    PointKey(Key<T> const & x, Key<T> const & y) : _x(x), _y(y) {}

    explicit PointKey(Key< Point<T> > const & other) : _x(other.getX()), _y(other.getY()) {}

    PointKey(SubSchema const & s) : _x(s["x"]), _y(s["y"]) {}

    virtual geom::Point<T,2> get(BaseRecord const & record) const;

    virtual void set(BaseRecord & record, geom::Point<T,2> const & value) const;

    bool operator==(PointKey<T> const & other) const { return _x == other._x && _y == other._y; }
    bool operator!=(PointKey<T> const & other) const { return !(*this == other); }

    bool isValid() const { return _x.isValid() && _y.isValid(); }

    Key<T> getX() const { return _x; }

    Key<T> getY() const { return _y; }

private:
    Key<T> _x;
    Key<T> _y;
};

typedef PointKey<int> Point2IKey;
typedef PointKey<double> Point2DKey;

class CoordKey : public FunctorKey < coord::IcrsCoord > {
public:
    static CoordKey addFields(
        afw::table::Schema & schema,
        std::string const & name,
        std::string const & doc
    );

    CoordKey() : _ra(), _dec() {}

    CoordKey(
        Key<geom::Angle> const & ra,
        Key<geom::Angle> const & dec
    ) :
        _ra(ra), _dec(dec)
    {}

    CoordKey(SubSchema const & s) : _ra(s["ra"]), _dec(s["dec"]) {}

    virtual coord::IcrsCoord get(BaseRecord const & record) const;

    virtual void set(BaseRecord & record, coord::IcrsCoord const & value) const;

    virtual void set(BaseRecord & record, coord::Coord const & value) const;

    bool isValid() const { return _ra.isValid() && _dec.isValid(); }

    Key<geom::Angle> getRa() const { return _ra; }
    Key<geom::Angle> getDec() const { return _dec; }

private:
    Key<geom::Angle> _ra;
    Key<geom::Angle> _dec;
};

bool operator==(CoordKey const & lhs, CoordKey const & rhs);
bool operator!=(CoordKey const & lhs, CoordKey const & rhs);

class QuadrupoleKey : public FunctorKey< lsst::afw::geom::ellipses::Quadrupole > {
public:

    static QuadrupoleKey addFields(
        Schema & schema,
        std::string const & name,
        std::string const & doc,
        CoordinateType coordType=CoordinateType::PIXEL
    );

    QuadrupoleKey() : _ixx(), _iyy(), _ixy() {}

    QuadrupoleKey(Key<double> const & ixx, Key<double> const & iyy, Key<double> const & ixy) :
        _ixx(ixx), _iyy(iyy), _ixy(ixy)
    {}

    explicit QuadrupoleKey(Key< Moments<double> > const & other) :
        _ixx(other.getIxx()), _iyy(other.getIyy()), _ixy(other.getIxy())
    {}

    QuadrupoleKey(SubSchema const & s): _ixx(s["xx"]), _iyy(s["yy"]), _ixy(s["xy"]) {}

    virtual geom::ellipses::Quadrupole get(BaseRecord const & record) const;

    virtual void set(BaseRecord & record, geom::ellipses::Quadrupole const & value) const;

    bool operator==(QuadrupoleKey const & other) const {
        return _ixx == other._ixx && _iyy == other._iyy && _ixy == other._ixy;
    }
    bool operator!=(QuadrupoleKey const & other) const { return !(*this == other); }

    bool isValid() const { return _ixx.isValid() && _iyy.isValid() && _ixy.isValid(); }

    Key<double> getIxx() const { return _ixx; }
    Key<double> getIyy() const { return _iyy; }
    Key<double> getIxy() const { return _ixy; }

private:
    Key<double> _ixx;
    Key<double> _iyy;
    Key<double> _ixy;
};


class EllipseKey : public FunctorKey< lsst::afw::geom::ellipses::Ellipse > {
public:

    static EllipseKey addFields(
        Schema & schema,
        std::string const & name,
        std::string const & doc,
        std::string const & unit
    );

    EllipseKey() : _qKey(), _pKey() {}

    EllipseKey(QuadrupoleKey const & qKey, PointKey<double> const & pKey) :
        _qKey(qKey), _pKey(pKey)
    {}

    EllipseKey(SubSchema const & s) : _qKey(s), _pKey(s) {}

    virtual geom::ellipses::Ellipse get(BaseRecord const & record) const;

    virtual void set(BaseRecord & record, geom::ellipses::Ellipse const & value) const;

    bool operator==(EllipseKey const & other) const {
        return _qKey == other._qKey && _pKey == other._pKey;
    }
    bool operator!=(EllipseKey const & other) const { return !(*this == other); }

    bool isValid() const { return _qKey.isValid() && _pKey.isValid(); }

    QuadrupoleKey getCore() const { return _qKey; }
    PointKey<double> getCenter() const { return _pKey; }

private:
    QuadrupoleKey _qKey;
    PointKey<double> _pKey;
};


template <typename T, int N>
class CovarianceMatrixKey : public FunctorKey< Eigen::Matrix<T,N,N> > {
public:

    typedef std::vector< Key<T> > SigmaKeyArray;
    typedef std::vector< Key<T> > CovarianceKeyArray;
    typedef std::vector<std::string> NameArray;

    CovarianceMatrixKey();

    explicit CovarianceMatrixKey(
        SigmaKeyArray const & sigma,
        CovarianceKeyArray const & cov=CovarianceKeyArray()
    );

    template <typename U>
    explicit CovarianceMatrixKey(Key< Covariance<U> > const & other);

    CovarianceMatrixKey(SubSchema const & s, NameArray const & names);

    virtual Eigen::Matrix<T,N,N> get(BaseRecord const & record) const;

    virtual void set(BaseRecord & record, Eigen::Matrix<T,N,N> const & value) const;

    T getElement(BaseRecord const & record, int i, int j) const;

    void setElement(BaseRecord & record, int i, int j, T value) const;

    bool isValid() const;

    bool operator==(CovarianceMatrixKey const & other) const;
    bool operator!=(CovarianceMatrixKey const & other) const { return !(*this == other); }

private:
    bool _isDiagonalVariance;
    SigmaKeyArray _sigma;
    CovarianceKeyArray _cov;
};

inline CovarianceMatrixKey<float,Eigen::Dynamic>
makeCovarianceMatrixKey(Key< Covariance<float> > const & other) {
    return CovarianceMatrixKey<float,Eigen::Dynamic>(other);
}

inline CovarianceMatrixKey<float,2>
makeCovarianceMatrixKey(Key< Covariance< Point<float> > > const & other) {
    return CovarianceMatrixKey<float,2>(other);
}

inline CovarianceMatrixKey<float,3>
makeCovarianceMatrixKey(Key< Covariance< Moments<float> > > const & other) {
    return CovarianceMatrixKey<float,3>(other);
}

}}} // namespace lsst::afw::table

#endif // !AFW_TABLE_aggregates_h_INCLUDED