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