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/utils/hashCombine.h"

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

namespace lsst {
namespace afw {
namespace geom {

namespace ellipses {

class Quadrupole;

}  // namespace ellipses
}  // namespace geom

namespace table {

template <typename T>
class PointKey : public FunctorKey<lsst::geom::Point<T, 2> > {
public:
    static PointKey addFields(Schema& schema, std::string const& name, std::string const& doc,
                              std::string const& unit);

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

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

    PointKey(PointKey const&) noexcept = default;
    PointKey(PointKey&&) noexcept = default;
    PointKey& operator=(PointKey const&) noexcept = default;
    PointKey& operator=(PointKey&&) noexcept = default;
    ~PointKey() noexcept override = default;

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

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

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

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

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(17, _x, _y);
    }

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

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

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

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

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

template <typename Box>
class BoxKey : public FunctorKey<Box> {
public:
    using Element = typename Box::Element;

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

    BoxKey() noexcept = default;

    BoxKey(PointKey<Element> const& min, PointKey<Element> const& max) noexcept : _min(min), _max(max) {}

    BoxKey(SubSchema const& s) : _min(s["min"]), _max(s["max"]) {}

    BoxKey(BoxKey const&) noexcept = default;
    BoxKey(BoxKey&&) noexcept = default;
    BoxKey& operator=(BoxKey const&) noexcept = default;
    BoxKey& operator=(BoxKey&&) noexcept = default;
    ~BoxKey() noexcept override = default;

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(17, _min, _max);
    }

    Box get(BaseRecord const& record) const override;

    void set(BaseRecord& record, Box const& value) const override;

    bool operator==(BoxKey const& other) const noexcept { return _min == other._min && _max == other._max; }
    bool operator!=(BoxKey const& other) const noexcept { return !(*this == other); }

    bool isValid() const noexcept { return _min.isValid() && _max.isValid(); }

    PointKey<Element> getMin() const noexcept { return _min; }

    PointKey<Element> getMax() const noexcept { return _max; }

private:
    PointKey<Element> _min;
    PointKey<Element> _max;
};

using Box2IKey = BoxKey<lsst::geom::Box2I>;
using Box2DKey = BoxKey<lsst::geom::Box2D>;

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

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

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

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

    CoordKey(CoordKey const&) noexcept = default;
    CoordKey(CoordKey&&) noexcept = default;
    CoordKey& operator=(CoordKey const&) noexcept = default;
    CoordKey& operator=(CoordKey&&) noexcept = default;
    ~CoordKey() noexcept override = default;

    lsst::geom::SpherePoint get(BaseRecord const& record) const override;

    void set(BaseRecord& record, lsst::geom::SpherePoint const& value) const override;

    bool operator==(CoordKey const& other) const noexcept { return _ra == other._ra && _dec == other._dec; }
    bool operator!=(CoordKey const& other) const noexcept { return !(*this == other); }

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(17, _ra, _dec);
    }

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

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

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

enum class CoordinateType { PIXEL, CELESTIAL };

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() noexcept : _ixx(), _iyy(), _ixy() {}

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

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

    QuadrupoleKey(QuadrupoleKey const&) noexcept = default;
    QuadrupoleKey(QuadrupoleKey&&) noexcept = default;
    QuadrupoleKey& operator=(QuadrupoleKey const&) noexcept = default;
    QuadrupoleKey& operator=(QuadrupoleKey&&) noexcept = default;
    ~QuadrupoleKey() noexcept override = default;

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

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

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

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(17, _ixx, _iyy, _ixy);
    }

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

    Key<double> getIxx() const noexcept { return _ixx; }
    Key<double> getIyy() const noexcept { return _iyy; }
    Key<double> getIxy() const noexcept { 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() noexcept : _qKey(), _pKey() {}

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

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

    EllipseKey(EllipseKey const&) noexcept = default;
    EllipseKey(EllipseKey&&) noexcept = default;
    EllipseKey& operator=(EllipseKey const&) noexcept = default;
    EllipseKey& operator=(EllipseKey&&) noexcept = default;
    ~EllipseKey() noexcept override = default;

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

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

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

    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(17, _qKey, _pKey);
    }

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

    QuadrupoleKey getCore() const noexcept { return _qKey; }
    PointKey<double> getCenter() const noexcept { 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> > ErrKeyArray;
    typedef std::vector<Key<T> > CovarianceKeyArray;
    typedef std::vector<std::string> NameArray;

    static CovarianceMatrixKey addFields(Schema& schema, std::string const& prefix, NameArray const& names,
                                         std::string const& unit, bool diagonalOnly = false);

    static CovarianceMatrixKey addFields(Schema& schema, std::string const& prefix, NameArray const& names,
                                         NameArray const& units, bool diagonalOnly = false);

    CovarianceMatrixKey();

    explicit CovarianceMatrixKey(ErrKeyArray const& err,
                                 CovarianceKeyArray const& cov = CovarianceKeyArray());

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

    CovarianceMatrixKey(CovarianceMatrixKey const&);
    CovarianceMatrixKey(CovarianceMatrixKey&&);
    CovarianceMatrixKey& operator=(CovarianceMatrixKey const&);
    CovarianceMatrixKey& operator=(CovarianceMatrixKey&&);
    ~CovarianceMatrixKey() noexcept override;

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

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

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

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

    bool isValid() const noexcept;

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

    std::size_t hash_value() const noexcept;

private:
    ErrKeyArray _err;
    CovarianceKeyArray _cov;
};
}  // namespace table
}  // namespace afw
}  // namespace lsst

namespace std {
template <typename T>
struct hash<lsst::afw::table::PointKey<T>> {
    using argument_type = lsst::afw::table::PointKey<T>;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};

template <typename T>
struct hash<lsst::afw::table::BoxKey<T>> {
    using argument_type = lsst::afw::table::BoxKey<T>;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};

template <>
struct hash<lsst::afw::table::CoordKey> {
    using argument_type = lsst::afw::table::CoordKey;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};

template <>
struct hash<lsst::afw::table::QuadrupoleKey> {
    using argument_type = lsst::afw::table::QuadrupoleKey;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};

template <>
struct hash<lsst::afw::table::EllipseKey> {
    using argument_type = lsst::afw::table::EllipseKey;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};

template <typename T, int N>
struct hash<lsst::afw::table::CovarianceMatrixKey<T, N>> {
    using argument_type = lsst::afw::table::CovarianceMatrixKey<T, N>;
    using result_type = size_t;
    size_t operator()(argument_type const& obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std

#endif  // !AFW_TABLE_aggregates_h_INCLUDED