Endpoint.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2017 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 LSST_AFW_GEOM_ENDPOINT_H
#define LSST_AFW_GEOM_ENDPOINT_H
 
#include <memory>
#include <vector>
 
#include "astshim.h"
#include "ndarray.h"
 
#include "lsst/geom/Point.h"
#include "lsst/geom/SpherePoint.h"
 
namespace lsst {
namespace afw {
namespace geom {
 
template <typename PointT, typename ArrayT>
class BaseEndpoint {
public:
    using Point = PointT;
    using Array = ArrayT;
 
    BaseEndpoint(BaseEndpoint const &) = default;
    BaseEndpoint(BaseEndpoint &&) = default;
    BaseEndpoint &operator=(BaseEndpoint const &) = delete;
    BaseEndpoint &operator=(BaseEndpoint &&) = delete;
 
    virtual ~BaseEndpoint() = default;
 
    int getNAxes() const { return _nAxes; }
 
    virtual int getNPoints(Array const &arr) const = 0;
 
    // Note: while defining operator==(BaseEndpoint<OtherPoint, OtherArray> const &)
    // would be more Pythonic, it's very hard to get such a method template to play well with pybind11
    virtual bool operator==(BaseEndpoint const &other) const noexcept;
 
    bool operator!=(BaseEndpoint const &other) const noexcept { return !(*this == other); }
 
    virtual std::vector<double> dataFromPoint(Point const &point) const = 0;
 
    virtual ndarray::Array<double, 2, 2> dataFromArray(Array const &arr) const = 0;
 
    virtual Point pointFromData(std::vector<double> const &data) const = 0;
 
    virtual Array arrayFromData(ndarray::Array<double, 2, 2> const &data) const = 0;
 
    virtual std::shared_ptr<ast::Frame> makeFrame() const;
 
    virtual void normalizeFrame(std::shared_ptr<ast::Frame> framePtr) const {};
 
protected:
    explicit BaseEndpoint(int nAxes);
 
    void _assertNAxes(int nAxes) const;
 
    int _getNAxes(ndarray::Array<double, 2, 2> const &data) const { return data.getSize<0>(); }
 
    int _getNAxes(ndarray::Array<double, 1, 1> const &data) const { return data.getSize<0>(); }
 
    int _getNAxes(std::vector<double> const &data) const { return data.size(); }
 
    int _getNPoints(ndarray::Array<double, 2, 2> const &data) const { return data.getSize<1>(); }
 
private:
    int _nAxes;  
};
 
template <typename PointT>
class BaseVectorEndpoint : public BaseEndpoint<PointT, std::vector<PointT>> {
public:
    using Array = std::vector<PointT>;
    using Point = PointT;
 
    BaseVectorEndpoint(BaseVectorEndpoint const &) = default;
    BaseVectorEndpoint(BaseVectorEndpoint &&) = default;
    BaseVectorEndpoint &operator=(BaseVectorEndpoint const &) = delete;
    BaseVectorEndpoint &operator=(BaseVectorEndpoint &&) = delete;
 
    ~BaseVectorEndpoint() override = default;
 
    int getNPoints(Array const &arr) const override;
 
protected:
    explicit BaseVectorEndpoint(int nAxes) : BaseEndpoint<Point, Array>(nAxes){};
};
 
class GenericEndpoint : public BaseEndpoint<std::vector<double>, ndarray::Array<double, 2, 2>> {
public:
    GenericEndpoint(GenericEndpoint const &) = default;
    GenericEndpoint(GenericEndpoint &&) = default;
    GenericEndpoint &operator=(GenericEndpoint const &) = delete;
    GenericEndpoint &operator=(GenericEndpoint &&) = delete;
 
    explicit GenericEndpoint(int nAxes) : BaseEndpoint(nAxes){};
 
    ~GenericEndpoint() override = default;
 
    int getNPoints(Array const &arr) const override { return arr.getSize<1>(); }
 
    std::vector<double> dataFromPoint(Point const &point) const override;
 
    ndarray::Array<double, 2, 2> dataFromArray(Array const &arr) const override;
 
    Point pointFromData(std::vector<double> const &data) const override;
 
    Array arrayFromData(ndarray::Array<double, 2, 2> const &data) const override;
 
    static std::string getClassPrefix() { return "Generic"; };
};
 
class Point2Endpoint : public BaseVectorEndpoint<lsst::geom::Point2D> {
public:
    Point2Endpoint(Point2Endpoint const &) = default;
    Point2Endpoint(Point2Endpoint &&) = default;
    Point2Endpoint &operator=(Point2Endpoint const &) = delete;
    Point2Endpoint &operator=(Point2Endpoint &&) = delete;
 
    explicit Point2Endpoint() : BaseVectorEndpoint<lsst::geom::Point2D>(2) {}
 
    explicit Point2Endpoint(int nAxes);
 
    ~Point2Endpoint() override = default;
 
    std::vector<double> dataFromPoint(Point const &point) const override;
 
    ndarray::Array<double, 2, 2> dataFromArray(Array const &arr) const override;
 
    Point pointFromData(std::vector<double> const &data) const override;
 
    Array arrayFromData(ndarray::Array<double, 2, 2> const &data) const override;
 
    void normalizeFrame(std::shared_ptr<ast::Frame> framePtr) const override;
 
    static std::string getClassPrefix() { return "Point2"; };
};
 
class SpherePointEndpoint : public BaseVectorEndpoint<lsst::geom::SpherePoint> {
public:
    SpherePointEndpoint(SpherePointEndpoint const &) = default;
    SpherePointEndpoint(SpherePointEndpoint &&) = default;
    SpherePointEndpoint &operator=(SpherePointEndpoint const &) = delete;
    SpherePointEndpoint &operator=(SpherePointEndpoint &&) = delete;
 
    explicit SpherePointEndpoint() : BaseVectorEndpoint(2) {}
 
    explicit SpherePointEndpoint(int nAxes);
 
    ~SpherePointEndpoint() override = default;
 
    std::vector<double> dataFromPoint(Point const &point) const override;
 
    ndarray::Array<double, 2, 2> dataFromArray(Array const &arr) const override;
 
    Point pointFromData(std::vector<double> const &data) const override;
 
    Array arrayFromData(ndarray::Array<double, 2, 2> const &data) const override;
 
    std::shared_ptr<ast::Frame> makeFrame() const override;
 
    void normalizeFrame(std::shared_ptr<ast::Frame> framePtr) const override;
 
    static std::string getClassPrefix() { return "SpherePoint"; };
};
 
std::ostream &operator<<(std::ostream &os, GenericEndpoint const &endpoint);
 
std::ostream &operator<<(std::ostream &os, Point2Endpoint const &endpoint);
 
std::ostream &operator<<(std::ostream &os, SpherePointEndpoint const &endpoint);
 
}  // namespace geom
}  // namespace afw
}  // namespace lsst
 
#endif