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, int N>
class CovarianceMatrixKey;
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;
};
 
using Point2IKey = PointKey<int>;
using Point2DKey = PointKey<double>;
 
template <typename T>
class Point3Key : public FunctorKey<lsst::geom::Point<T, 3> > {
public:
    static Point3Key addFields(Schema& schema, std::string const& name, std::string const& doc,
                               std::string const& unit);
 
    Point3Key() noexcept : _x(), _y(), _z() {}
 
    Point3Key(Key<T> const& x, Key<T> const& y, Key<T> const& z) noexcept : _x(x), _y(y), _z(z) {}
 
    Point3Key(Point3Key const&) noexcept = default;
    Point3Key(Point3Key&&) noexcept = default;
    Point3Key& operator=(Point3Key const&) noexcept = default;
    Point3Key& operator=(Point3Key&&) noexcept = default;
    ~Point3Key() noexcept override = default;
 
    Point3Key(SubSchema const& s) : _x(s["x"]), _y(s["y"]), _z(s["z"]) {}
 
    lsst::geom::Point<T, 3> get(BaseRecord const& record) const override;
 
    void set(BaseRecord& record, lsst::geom::Point<T, 3> const& value) const override;
 
 
    bool operator==(Point3Key<T> const& other) const noexcept {
        return _x == other._x && _y == other._y && _z == other._z; }
    bool operator!=(Point3Key<T> const& other) const noexcept { return !(*this == other); }
 
    std::size_t hash_value() const noexcept {
        // Completely arbitrary seed
        return utils::hashCombine(137, _x, _y, _z);
    }
 
    bool isValid() const noexcept { return _x.isValid() && _y.isValid() && _z.isValid(); }
 
    Key<T> getX() const noexcept { return _x; }
 
    Key<T> getY() const noexcept { return _y; }
 
    Key<T> getZ() const noexcept { return _z; }
 
private:
    Key<T> _x;
    Key<T> _y;
    Key<T> _z;
};
 
using Point3IKey = Point3Key<int>;
using Point3DKey = Point3Key<double>;
 
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);
    
    using ErrorKey = CovarianceMatrixKey<float, 2>;
    static ErrorKey getErrorKey(Schema const & schema);
 
    static ErrorKey addErrorFields(Schema & schema);
 
    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:
    using ErrKeyArray = std::vector<Key<T>>;
    using CovarianceKeyArray = std::vector<Key<T>>;
    using NameArray = std::vector<std::string>;
 
    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;
};
 
class CoordErrKey : public CovarianceMatrixKey<float, 2> {
public:
    using ErrKeyArray = std::vector<Key<float>>;
    using CovarianceKeyArray = std::vector<Key<float>>;
    using NameArray = std::vector<std::string>;
 
    static CoordErrKey addFields(Schema& schema, std::string const& name, std::string const& unit,
                                 bool diagonalOnly = false);
    static CoordErrKey addFields(Schema& schema, std::string const& name, NameArray const& units,
                                 bool diagonalOnly = false);
    
    CoordErrKey();
 
    explicit CoordErrKey(ErrKeyArray const& err,
                         CovarianceKeyArray const& cov = CovarianceKeyArray());
    CoordErrKey(SubSchema const& s, std::string const& name);
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