TransformMap.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_TRANSFORMMAP_H)
#define LSST_AFW_CAMERAGEOM_TRANSFORMMAP_H

#include <vector>
#include <unordered_map>
#include <memory>

#include "boost/iterator/transform_iterator.hpp"
#include "astshim/FrameSet.h"

#include "lsst/afw/table/io/Persistable.h"
#include "lsst/afw/cameraGeom/CameraSys.h"
#include "lsst/geom/Point.h"
#include "lsst/afw/geom/Transform.h"

namespace lsst {
namespace afw {
namespace cameraGeom {

class TransformMap final : public table::io::PersistableFacade<TransformMap>, public table::io::Persistable {
private:

    // Functor for boost::transform_iterator: given an entry in a std::map or unordered_map, return the key
    struct GetKey {
        CameraSys const &operator()(std::pair<const CameraSys, int> const &p) const { return p.first; };
    };

    using CameraSysFrameIdMap = std::unordered_map<CameraSys, int>;

public:

    using Transforms = std::unordered_map<CameraSys, std::shared_ptr<geom::TransformPoint2ToPoint2>>;
    using CameraSysIterator = boost::transform_iterator<GetKey, CameraSysFrameIdMap::const_iterator>;

    class Builder;

    static std::shared_ptr<TransformMap const> make(
        CameraSys const &reference,
        Transforms const &transforms
    );

    TransformMap(TransformMap const &other) = delete;
    TransformMap(TransformMap &&other) = delete;
    TransformMap &operator=(TransformMap const &) = delete;
    TransformMap &operator=(TransformMap &&) = delete;

    ~TransformMap() noexcept;

    lsst::geom::Point2D transform(lsst::geom::Point2D const &point, CameraSys const &fromSys,
                                  CameraSys const &toSys) const;

    std::vector<lsst::geom::Point2D> transform(std::vector<lsst::geom::Point2D> const &pointList,
                                               CameraSys const &fromSys, CameraSys const &toSys) const;

    CameraSysIterator begin() const { return boost::make_transform_iterator(_frameIds.begin(), GetKey()); }

    CameraSysIterator end() const { return boost::make_transform_iterator(_frameIds.end(), GetKey()); }

    bool contains(CameraSys const &system) const noexcept;

    std::shared_ptr<geom::TransformPoint2ToPoint2> getTransform(CameraSys const &fromSys,
                                                                CameraSys const &toSys) const;

    size_t size() const noexcept;


    bool isPersistable() const noexcept override { return true; }

private:

    // Helper class used in persistence.
    class Factory;

    static Factory const registration;

    // Private ctor, only called by Builder::build() and Factory.
    TransformMap(std::unique_ptr<ast::FrameSet> && transforms,
                 CameraSysFrameIdMap && frameIds,
                 std::vector<std::pair<int, int>> && canonicalConnections);

    int _getFrame(CameraSys const &system) const;

    std::shared_ptr<ast::Mapping const> _getMapping(CameraSys const &fromSys, CameraSys const &toSys) const;

    std::string getPersistenceName() const override;

    std::string getPythonModule() const override;

    void write(OutputArchiveHandle& handle) const override;


    static lsst::afw::geom::Point2Endpoint _pointConverter;

    std::unique_ptr<ast::FrameSet const> const _transforms;

    CameraSysFrameIdMap const _frameIds;

    std::vector<std::pair<int, int>> const _canonicalConnections;
};


class TransformMap::Builder {
public:

    explicit Builder(CameraSys const & reference);

    Builder(Builder const &);
    Builder(Builder &&);  // std::vector move construct is not noexcept until C++17
    Builder & operator=(Builder const &);
    Builder & operator=(Builder &&);  // std::vector move assignment is not noexcept until C++17

    ~Builder() noexcept;

    Builder & connect(CameraSys const & fromSys, CameraSys const & toSys,
                      std::shared_ptr<geom::TransformPoint2ToPoint2 const> transform);

    Builder & connect(CameraSys const & fromSys, Transforms const &transforms);

    Builder & connect(Transforms const &transforms) {
        return connect(_reference, transforms);
    }

    std::shared_ptr<TransformMap const> build() const;

private:

    struct Connection {
        mutable bool processed;
        std::shared_ptr<geom::TransformPoint2ToPoint2 const> transform;
        CameraSys fromSys;
        CameraSys toSys;
    };

    CameraSys _reference;
    std::vector<Connection> _connections;
};


}  // namespace cameraGeom
}  // namespace afw
}  // namespace lsst

#endif