Frame.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2017 AURA/LSST.
 *
 * 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 <https://www.lsstcorp.org/LegalNotices/>.
 */
#ifndef ASTSHIM_FRAME_H
#define ASTSHIM_FRAME_H
 
#include <memory>
#include <sstream>
#include <stdexcept>
#include <utility>
 
#include "astshim/Mapping.h"
#include "astshim/Object.h"
#include "astshim/base.h"
#include "astshim/detail/utils.h"
 
namespace ast {
 
class CmpFrame;
class Frame;
 
class DirectionPoint {
public:
    DirectionPoint(double direction, PointD const &point) : direction(direction), point(point){};
    double direction;  
    PointD point;      
};
 
class NReadValue {
public:
    NReadValue(int nread, double value) : nread(nread), value(value){};
    int nread;     
    double value;  
};
 
class ResolvedPoint {
public:
    explicit ResolvedPoint(int naxes) : point(naxes), d1(), d2() {}
    std::vector<double> point;  
    double d1;                  
    double d2;                  
};
 
class FrameMapping {
public:
    FrameMapping(std::shared_ptr<Frame> frame, std::shared_ptr<Mapping> mapping)
            : frame(frame), mapping(mapping) {}
    std::shared_ptr<Frame> frame;      
    std::shared_ptr<Mapping> mapping;  
};
 
class FrameSet;
 
class Frame : public Mapping {
    friend class Object;
 
public:
    explicit Frame(int naxes, std::string const &options = "")
            : Mapping(reinterpret_cast<AstMapping *>(astFrame(naxes, "%s", options.c_str()))) {
        assertOK();
    }
 
    virtual ~Frame() {}
 
    Frame(Frame const &) = default;
    Frame(Frame &&) = default;
    Frame &operator=(Frame const &) = delete;
    Frame &operator=(Frame &&) = default;
 
    std::shared_ptr<Frame> copy() const { return std::static_pointer_cast<Frame>(copyPolymorphic()); }
 
    double angle(PointD const &a, PointD const &b, PointD const &c) const {
        assertPointLength(a, "a");
        assertPointLength(b, "b");
        assertPointLength(c, "c");
        return detail::safeDouble(astAngle(getRawPtr(), a.data(), b.data(), c.data()));
    }
 
    double axAngle(PointD const &a, PointD const &b, int axis) const {
        assertPointLength(a, "a");
        assertPointLength(b, "b");
        return detail::safeDouble(astAxAngle(getRawPtr(), a.data(), b.data(), axis));
    }
 
    double axDistance(int axis, double v1, double v2) const {
        return detail::safeDouble(astAxDistance(getRawPtr(), axis, v1, v2));
    }
 
    double axOffset(int axis, double v1, double dist) const {
        return detail::safeDouble(astAxOffset(getRawPtr(), axis, v1, dist));
    }
 
    std::shared_ptr<FrameSet> convert(Frame const &to, std::string const &domainlist = "");
 
    double distance(PointD const &point1, PointD const &point2) const {
        assertPointLength(point1, "point1");
        assertPointLength(point2, "point2");
        return detail::safeDouble(astDistance(getRawPtr(), point1.data(), point2.data()));
    }
 
    std::shared_ptr<FrameSet> findFrame(Frame const &tmplt, std::string const &domainlist = "");
 
    std::string format(int axis, double value) const {
        char const *rawstr = astFormat(getRawPtr(), axis, value);
        assertOK();
        return std::string(rawstr);
    }
 
    bool getActiveUnit() const {
        bool ret = astGetActiveUnit(getRawPtr());
        assertOK();
        return ret;
    }
 
    std::string getAlignSystem() const { return getC("AlignSystem"); }
 
    double getBottom(int axis) const { return getD(detail::formatAxisAttr("Bottom", axis)); }
 
    int getDigits() const { return getI("Digits"); }
 
    int getDigits(int axis) const { return getI(detail::formatAxisAttr("Digits", axis)); }
 
    bool getDirection(int axis) const { return getB(detail::formatAxisAttr("Direction", axis)); }
 
    std::string getDomain() const { return getC("Domain"); }
 
    double getDut1() const { return getD("Dut1"); }
 
    double getEpoch() const { return getD("Epoch"); }
 
    std::string getFormat(int axis) const { return getC(detail::formatAxisAttr("Format", axis)); }
 
    std::string getInternalUnit(int axis) const { return getC(detail::formatAxisAttr("InternalUnit", axis)); }
 
    std::string getLabel(int axis) const { return getC(detail::formatAxisAttr("Label", axis)); }
 
    bool getMatchEnd() const { return getB("MatchEnd"); }
 
    int getMaxAxes() const { return getI("MaxAxes"); }
 
    int getMinAxes() const { return getI("MinAxes"); }
 
    int getNAxes() const { return getI("NAxes"); }
 
    std::string getNormUnit(int axis) const { return getC(detail::formatAxisAttr("NormUnit", axis)); }
 
    double getObsAlt() const { return getD("ObsAlt"); }
 
    std::string getObsLat() const { return getC("ObsLat"); }
 
    std::string getObsLon() const { return getC("ObsLon"); }
 
    bool getPermute() const { return getB("Permute"); }
 
    bool getPreserveAxes() const { return getB("PreserveAxes"); }
 
    std::string getSymbol(int axis) const { return getC(detail::formatAxisAttr("Symbol", axis)); }
 
    std::string getSystem() const { return getC("System"); }
 
    std::string getTitle() const { return getC("Title"); }
 
    double getTop(int axis) const { return getD(detail::formatAxisAttr("Top", axis)); }
 
    std::string getUnit(int axis) const { return getC(detail::formatAxisAttr("Unit", axis)); }
 
    std::vector<double> intersect(std::vector<double> const &a1, std::vector<double> const &a2,
                                  std::vector<double> const &b1, std::vector<double> const &b2) const;
 
    std::vector<int> matchAxes(Frame const &other) const {
        std::vector<int> ret(other.getNIn());
        astMatchAxes(getRawPtr(), other.getRawPtr(), ret.data());
        assertOK();
        return ret;
    }
 
    CmpFrame under(Frame const &next) const;
 
    PointD norm(PointD value) const {
        astNorm(getRawPtr(), value.data());
        assertOK();
        detail::astBadToNan(value);
        return value;
    }
 
    PointD offset(PointD point1, PointD point2, double offset) const {
        assertPointLength(point1, "point1");
        assertPointLength(point2, "point2");
        PointD ret(getNIn());
        astOffset(getRawPtr(), point1.data(), point2.data(), offset, ret.data());
        assertOK();
        detail::astBadToNan(ret);
        return ret;
    }
 
    DirectionPoint offset2(PointD const &point1, double angle, double offset) const {
        detail::assertEqual(getNIn(), "naxes", 2, " cannot call offset2");
        assertPointLength(point1, "point1");
        PointD point2(getNIn());
        double offsetAngle = astOffset2(getRawPtr(), point1.data(), angle, offset, point2.data());
        assertOK();
        detail::astBadToNan(point2);
        return DirectionPoint(detail::safeDouble(offsetAngle), point2);
    }
 
    void permAxes(std::vector<int> perm) {
        detail::assertEqual(perm.size(), "perm.size()", static_cast<std::size_t>(getNAxes()), "naxes");
        astPermAxes(getRawPtr(), perm.data());
        assertOK();
    }
 
    FrameMapping pickAxes(std::vector<int> const &axes) const;
 
    ResolvedPoint resolve(std::vector<double> const &point1, std::vector<double> const &point2,
                          std::vector<double> const &point3) const;
 
    void setAlignSystem(std::string const &system) { setC("AlignSystem", system); }
 
    void setBottom(int axis, double bottom) { setD(detail::formatAxisAttr("Bottom", axis), bottom); }
 
    void setDigits(int digits) { setI("Digits", digits); }
 
    void setDigits(int axis, int digits) { setD(detail::formatAxisAttr("Digits", axis), digits); }
 
    void setDirection(bool direction, int axis) {
        setB(detail::formatAxisAttr("Direction", axis), direction);
    }
 
    virtual void setDomain(std::string const &domain) { setC("Domain", domain); }
 
    void setDut1(double dut1) { setD("Dut1", dut1); }
 
    void setEpoch(double epoch) { setD("Epoch", epoch); }
 
    void setEpoch(std::string const &epoch) { setC("Epoch", epoch); }
 
    void setFormat(int axis, std::string const &format) {
        setC(detail::formatAxisAttr("Format", axis), format);
    }
 
    void setLabel(int axis, std::string const &label) { setC(detail::formatAxisAttr("Label", axis), label); }
 
    void setMatchEnd(bool match) { setB("MatchEnd", match); }
 
    void setMaxAxes(int maxAxes) { setI("MaxAxes", maxAxes); }
 
    void setMinAxes(int minAxes) { setI("MinAxes", minAxes); }
 
    void setObsAlt(double alt) { setD("ObsAlt", alt); }
 
    void setObsLat(std::string const &lat) { setC("ObsLat", lat); }
 
    void setObsLon(std::string const &lon) { setC("ObsLon", lon); }
 
    void setActiveUnit(bool enable) {
        astSetActiveUnit(getRawPtr(), enable);
        assertOK();
    }
 
    void setPermute(bool permute) { setB("Permute", permute); }
 
    void setPreserveAxes(bool preserve) { setB("PreserveAxes", preserve); }
 
    void setSymbol(int axis, std::string const &symbol) {
        setC(detail::formatAxisAttr("Symbol", axis), symbol);
    }
 
    void setSystem(std::string const &system) { setC("System", system); }
 
    void setTitle(std::string const &title) { setC("Title", title); }
 
    void setTop(int axis, double top) { setD(detail::formatAxisAttr("Top", axis), top); }
 
    void setUnit(int axis, std::string const &unit) { setC(detail::formatAxisAttr("Unit", axis), unit); }
 
    NReadValue unformat(int axis, std::string const &str) const {
        double value;
        int nread = astUnformat(getRawPtr(), axis, str.c_str(), &value);
        assertOK();
        return NReadValue(nread, detail::safeDouble(value));
    }
 
protected:
    explicit Frame(AstFrame *rawPtr) : Mapping(reinterpret_cast<AstMapping *>(rawPtr)) {
        if (!astIsAFrame(getRawPtr())) {
            std::ostringstream os;
            os << "This is a " << getClassName() << ", which is not a Frame";
            throw std::invalid_argument(os.str());
        }
    }
 
    virtual std::shared_ptr<Object> copyPolymorphic() const override { return copyImpl<Frame, AstFrame>(); }
 
private:
    template <typename T>
    void assertPointLength(T const &p, char const *name) const {
        if (static_cast<int>(p.size()) != getNIn()) {
            std::ostringstream os;
            os << "point " << name << " has " << p.size() << " axes, but " << getNIn() << " required";
            throw std::invalid_argument(os.str());
        }
    }
};
 
}  // namespace ast
 
#endif