CameraSys.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 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/>.
 */

#if !defined(LSST_AFW_CAMERAGEOM_CAMERASYS_H)
#define LSST_AFW_CAMERAGEOM_CAMERASYS_H

#include <functional>
#include <string>
#include <ostream>
#include <sstream>

namespace lsst {
namespace afw {
namespace cameraGeom {

class CameraSysPrefix final {
public:
    explicit CameraSysPrefix(std::string const &sysName  
                             )
            : _sysName(sysName) {}

    ~CameraSysPrefix() noexcept = default;
    CameraSysPrefix(CameraSysPrefix const &) = default;
    CameraSysPrefix(CameraSysPrefix &&) noexcept = default;
    CameraSysPrefix &operator=(CameraSysPrefix const &) = default;
    CameraSysPrefix &operator=(CameraSysPrefix &&) noexcept = default;

    std::string getSysName() const { return _sysName; };

    bool operator==(CameraSysPrefix const &rhs) const noexcept { return _sysName == rhs.getSysName(); }

    bool operator!=(CameraSysPrefix const &rhs) const noexcept { return !(*this == rhs); }

    std::size_t hash_value() const noexcept;

private:
    std::string _sysName;  
};

class CameraSys final {
public:
    explicit CameraSys(std::string const &sysName,           
                       std::string const &detectorName = ""  
                       )
            : _sysName(sysName), _detectorName(detectorName){};

    explicit CameraSys(CameraSysPrefix const &sysPrefix,     
                       std::string const &detectorName = ""  
                       )
            : _sysName(sysPrefix.getSysName()), _detectorName(detectorName){};

    ~CameraSys() noexcept = default;
    CameraSys(CameraSys const &) = default;
    CameraSys(CameraSys &&) noexcept = default;
    CameraSys &operator=(CameraSys const &) = default;
    CameraSys &operator=(CameraSys &&) noexcept = default;

    void swap(CameraSys & other) noexcept {
        std::swap(_sysName, other._sysName);
        std::swap(_detectorName, other._detectorName);
    }

    std::string getSysName() const { return _sysName; };

    std::string getDetectorName() const { return _detectorName; };

    bool hasDetectorName() const noexcept { return !_detectorName.empty(); }

    bool operator==(CameraSys const &rhs) const noexcept {
        return _sysName == rhs.getSysName() && _detectorName == rhs.getDetectorName();
    }

    bool operator!=(CameraSys const &rhs) const noexcept { return !(*this == rhs); }

    // less-than operator required for use in std::map
    bool operator<(CameraSys const &rhs) const noexcept {
        if (_sysName == rhs.getSysName()) {
            return _detectorName < rhs.getDetectorName();
        } else {
            return _sysName < rhs.getSysName();
        }
    }

    size_t hash_value() const noexcept;

private:
    std::string _sysName;       
    std::string _detectorName;  
};

inline void swap(CameraSys & a, CameraSys & b) {
    a.swap(b);
}


// *** Standard camera coordinate systems ***

extern CameraSys const FOCAL_PLANE;

extern CameraSys const FIELD_ANGLE;

extern CameraSysPrefix const PIXELS;

extern CameraSysPrefix const TAN_PIXELS;

extern CameraSysPrefix const ACTUAL_PIXELS;

std::ostream &operator<<(std::ostream &os, CameraSysPrefix const &detSysPrefix);

std::ostream &operator<<(std::ostream &os, CameraSys const &cameraSys);
}  // namespace cameraGeom
}  // namespace afw
}  // namespace lsst

namespace std {

inline void swap(lsst::afw::cameraGeom::CameraSys & a, lsst::afw::cameraGeom::CameraSys & b) noexcept {
    a.swap(b);
}

template <>
struct hash<lsst::afw::cameraGeom::CameraSysPrefix> {
    using argument_type = lsst::afw::cameraGeom::CameraSysPrefix;
    using result_type = size_t;
    size_t operator()(lsst::afw::cameraGeom::CameraSysPrefix const &obj) const noexcept {
        return obj.hash_value();
    }
};

template <>
struct hash<lsst::afw::cameraGeom::CameraSys> {
    using argument_type = lsst::afw::cameraGeom::CameraSys;
    using result_type = size_t;
    size_t operator()(lsst::afw::cameraGeom::CameraSys const &obj) const noexcept { return obj.hash_value(); }
};
}  // namespace std

#endif