SipTransform.h

Go to the documentation of this file.

// -*- LSST-C++ -*-

/*
 * LSST Data Management System
 * Copyright 2016 LSST/AURA
 *
 * 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_MEAS_ASTROM_SipTransform_INCLUDED
#define LSST_MEAS_ASTROM_SipTransform_INCLUDED

#include "lsst/geom/Extent.h"
#include "lsst/geom/Point.h"
#include "lsst/geom/SpherePoint.h"
#include "lsst/geom/AffineTransform.h"
#include "lsst/geom/LinearTransform.h"
#include "lsst/afw/geom/SkyWcs.h"
#include "lsst/meas/astrom/PolynomialTransform.h"

namespace lsst {
namespace meas {
namespace astrom {

class SipTransformBase {
public:
    geom::Point2D const& getPixelOrigin() const { return _pixelOrigin; }

    geom::LinearTransform const& getCdMatrix() const { return _cdMatrix; }

    PolynomialTransform const& getPoly() const { return _poly; }

protected:
    SipTransformBase(geom::Point2D const& pixelOrigin, geom::LinearTransform const& cdMatrix,
                     PolynomialTransform const& poly)
            : _pixelOrigin(pixelOrigin), _cdMatrix(cdMatrix), _poly(poly) {}

    SipTransformBase(SipTransformBase const& other) = default;
    SipTransformBase(SipTransformBase&& other) = default;
    SipTransformBase& operator=(SipTransformBase const& other) = default;
    SipTransformBase& operator=(SipTransformBase&& other) = default;

    void swap(SipTransformBase& other) {
        std::swap(_pixelOrigin, other._pixelOrigin);
        std::swap(_cdMatrix, other._cdMatrix);
        _poly.swap(other._poly);
    }

    void transformPixelsInPlace(geom::AffineTransform const& s);

    geom::Point2D _pixelOrigin;
    geom::LinearTransform _cdMatrix;
    PolynomialTransform _poly;
};

class SipForwardTransform : public SipTransformBase {
public:
    static SipForwardTransform convert(PolynomialTransform const& poly, geom::Point2D const& pixelOrigin,
                                       geom::LinearTransform const& cdMatrix);

    static SipForwardTransform convert(ScaledPolynomialTransform const& scaled,
                                       geom::Point2D const& pixelOrigin,
                                       geom::LinearTransform const& cdMatrix);

    static SipForwardTransform convert(ScaledPolynomialTransform const& scaled);

    SipForwardTransform(geom::Point2D const& pixelOrigin, geom::LinearTransform const& cdMatrix,
                        PolynomialTransform const& forwardSipPoly)
            : SipTransformBase(pixelOrigin, cdMatrix, forwardSipPoly) {}

    SipForwardTransform(SipForwardTransform const& other) = default;

    SipForwardTransform(SipForwardTransform&& other) = default;

    SipForwardTransform& operator=(SipForwardTransform const& other) = default;

    SipForwardTransform& operator=(SipForwardTransform&& other) = default;

    void swap(SipForwardTransform& other) { SipTransformBase::swap(other); }

    geom::AffineTransform linearize(geom::Point2D const& in) const;

    geom::Point2D operator()(geom::Point2D const& uv) const;

    SipForwardTransform transformPixels(geom::AffineTransform const& s) const;
};

class SipReverseTransform : public SipTransformBase {
public:
    static SipReverseTransform convert(PolynomialTransform const& poly, geom::Point2D const& pixelOrigin,
                                       geom::LinearTransform const& cdMatrix);

    static SipReverseTransform convert(ScaledPolynomialTransform const& scaled,
                                       geom::Point2D const& pixelOrigin,
                                       geom::LinearTransform const& cdMatrix);

    static SipReverseTransform convert(ScaledPolynomialTransform const& scaled);

    SipReverseTransform(geom::Point2D const& pixelOrigin, geom::LinearTransform const& cdMatrix,
                        PolynomialTransform const& reverseSipPoly)
            : SipTransformBase(pixelOrigin, cdMatrix, reverseSipPoly), _cdInverse(cdMatrix.inverted()) {}

    SipReverseTransform(SipReverseTransform const& other) = default;

    SipReverseTransform(SipReverseTransform&& other) = default;

    SipReverseTransform& operator=(SipReverseTransform const& other) = default;

    SipReverseTransform& operator=(SipReverseTransform&& other) = default;

    void swap(SipReverseTransform& other) {
        SipTransformBase::swap(other);
        std::swap(_cdInverse, other._cdInverse);
    }

    geom::AffineTransform linearize(geom::Point2D const& in) const;

    geom::Point2D operator()(geom::Point2D const& xy) const;

    SipReverseTransform transformPixels(geom::AffineTransform const& s) const;

private:
    friend class PolynomialTransform;
    friend class ScaledPolynomialTransform;
    geom::LinearTransform _cdInverse;
};

std::shared_ptr<afw::geom::SkyWcs> makeWcs(SipForwardTransform const& sipForward,
                                           SipReverseTransform const& sipReverse,
                                           geom::SpherePoint const& skyOrigin);

std::shared_ptr<afw::geom::SkyWcs> transformWcsPixels(afw::geom::SkyWcs const& wcs,
                                                      geom::AffineTransform const& s);

std::shared_ptr<afw::geom::SkyWcs> rotateWcsPixelsBy90(afw::geom::SkyWcs const& wcs, int nQuarter,
                                                       geom::Extent2I const& dimensions);

}  // namespace astrom
}  // namespace meas
}  // namespace lsst

#endif  // !LSST_MEAS_ASTROM_SipTransform_INCLUDED