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