warpExposure.h

Go to the documentation of this file.

// -*- LSST-C++ -*- // fixed format comment for emacs
 
/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 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/>.
 */
 
/*
 * Support for warping an image to a new WCS.
 */
 
#ifndef LSST_AFW_MATH_WARPEXPOSURE_H
#define LSST_AFW_MATH_WARPEXPOSURE_H
 
#include <memory>
#include <string>
 
#include "lsst/base.h"
#include "lsst/pex/exceptions.h"
#include "lsst/geom.h"
#include "lsst/afw/geom.h"
#include "lsst/afw/image/LsstImageTypes.h"
#include "lsst/afw/image/Exposure.h"
#include "lsst/afw/math/ConvolveImage.h"
#include "lsst/afw/math/Function.h"
#include "lsst/afw/math/FunctionLibrary.h"
#include "lsst/afw/math/Kernel.h"
#include "lsst/afw/table/io/Persistable.h"
 
namespace lsst {
namespace afw {
namespace geom {
class SkyWcs;
}
namespace math {
 
class LanczosWarpingKernel : public SeparableKernel {
public:
    explicit LanczosWarpingKernel(int order  
                                  )
            : SeparableKernel(2 * order, 2 * order, LanczosFunction1<Kernel::Pixel>(order),
                              LanczosFunction1<Kernel::Pixel>(order)) {}
 
    LanczosWarpingKernel(const LanczosWarpingKernel &) = delete;
    LanczosWarpingKernel(LanczosWarpingKernel &&) = delete;
    LanczosWarpingKernel &operator=(const LanczosWarpingKernel &) = delete;
    LanczosWarpingKernel &operator=(LanczosWarpingKernel &&) = delete;
 
    ~LanczosWarpingKernel() override = default;
 
    std::shared_ptr<Kernel> clone() const override;
 
    int getOrder() const;
 
    bool isPersistable() const noexcept override { return true; }
 
protected:
    void setKernelParameter(unsigned int ind, double value) const override;
 
    std::string getPersistenceName() const override { return "LanczosWarpingKernel"; }
 
    std::string getPythonModule() const override { return "lsst.afw.math"; }
 
    void write(OutputArchiveHandle &handle) const override;
};
 
class BilinearWarpingKernel : public SeparableKernel {
public:
    explicit BilinearWarpingKernel()
            : SeparableKernel(2, 2, BilinearFunction1(0.0), BilinearFunction1(0.0)) {}
 
    BilinearWarpingKernel(const BilinearWarpingKernel &) = delete;
    BilinearWarpingKernel(BilinearWarpingKernel &&) = delete;
    BilinearWarpingKernel &operator=(const BilinearWarpingKernel &) = delete;
    BilinearWarpingKernel &operator=(BilinearWarpingKernel &&) = delete;
 
    ~BilinearWarpingKernel() override = default;
 
    std::shared_ptr<Kernel> clone() const override;
 
    bool isPersistable() const noexcept override { return true; }
 
    class BilinearFunction1 : public Function1<Kernel::Pixel> {
    public:
        using Function1Ptr = std::shared_ptr<Function1<Kernel::Pixel>>;
 
        explicit BilinearFunction1(double fracPos)  
                : Function1<Kernel::Pixel>(1) {
            this->_params[0] = fracPos;
        }
        ~BilinearFunction1() override {}
 
        Function1Ptr clone() const override { return Function1Ptr(new BilinearFunction1(this->_params[0])); }
 
        Kernel::Pixel operator()(double x) const override;
 
        std::string toString(std::string const & = "") const override;
    };
 
protected:
    void setKernelParameter(unsigned int ind, double value) const override;
 
    std::string getPersistenceName() const override { return "BillinearWarpingKernel"; }
 
    std::string getPythonModule() const override { return "lsst.afw.math"; }
 
    void write(OutputArchiveHandle &handle) const override;
};
 
class NearestWarpingKernel : public SeparableKernel {
public:
    explicit NearestWarpingKernel() : SeparableKernel(2, 2, NearestFunction1(0.0), NearestFunction1(0.0)) {}
 
    NearestWarpingKernel(const NearestWarpingKernel &) = delete;
    NearestWarpingKernel(NearestWarpingKernel &&) = delete;
    NearestWarpingKernel &operator=(const NearestWarpingKernel &) = delete;
    NearestWarpingKernel &operator=(NearestWarpingKernel &&) = delete;
 
    ~NearestWarpingKernel() override = default;
 
    std::shared_ptr<Kernel> clone() const override;
 
    bool isPersistable() const noexcept override { return true; }
 
    class NearestFunction1 : public Function1<Kernel::Pixel> {
    public:
        using Function1Ptr = std::shared_ptr<Function1<Kernel::Pixel>>;
 
        explicit NearestFunction1(double fracPos)  
                : Function1<Kernel::Pixel>(1) {
            this->_params[0] = fracPos;
        }
        ~NearestFunction1() override {}
 
        Function1Ptr clone() const override { return Function1Ptr(new NearestFunction1(this->_params[0])); }
 
        Kernel::Pixel operator()(double x) const override;
 
        std::string toString(std::string const & = "") const override;
    };
 
protected:
    void setKernelParameter(unsigned int ind, double value) const override;
 
    std::string getPersistenceName() const override { return "NearestWarpingKernel"; }
 
    std::string getPythonModule() const override { return "lsst.afw.math"; }
 
    void write(OutputArchiveHandle &handle) const override;
};
 
std::shared_ptr<SeparableKernel> makeWarpingKernel(std::string name);
 
class WarpingControl final : public table::io::PersistableFacade<WarpingControl>,
                             public table::io::Persistable {
public:
    explicit WarpingControl(
            std::string const &warpingKernelName,  
            std::string const &maskWarpingKernelName = "",  
            int cacheSize = 0,  
            int interpLength = 0,  
            lsst::afw::image::MaskPixel growFullMask = 0
            )
            : _warpingKernelPtr(makeWarpingKernel(warpingKernelName)),
              _maskWarpingKernelPtr(),
              _cacheSize(cacheSize),
              _interpLength(interpLength),
              _growFullMask(growFullMask) {
        setMaskWarpingKernelName(maskWarpingKernelName);
    }
 
    virtual ~WarpingControl(){};
 
    int getCacheSize() const { return _cacheSize; };
 
    void setCacheSize(int cacheSize  
    ) {
        _cacheSize = cacheSize;
    };
 
    int getInterpLength() const { return _interpLength; };
 
    void setInterpLength(int interpLength  
    ) {
        _interpLength = interpLength;
    };
 
    std::shared_ptr<SeparableKernel> getWarpingKernel() const;
 
    void setWarpingKernelName(std::string const &warpingKernelName  
    );
 
    void setWarpingKernel(SeparableKernel const &warpingKernel  
    );
 
    std::shared_ptr<SeparableKernel> getMaskWarpingKernel() const;
 
    bool hasMaskWarpingKernel() const { return static_cast<bool>(_maskWarpingKernelPtr); }
 
    void setMaskWarpingKernelName(std::string const &maskWarpingKernelName
    );
 
    void setMaskWarpingKernel(SeparableKernel const &maskWarpingKernel  
    );
 
    lsst::afw::image::MaskPixel getGrowFullMask() const { return _growFullMask; };
 
    void setGrowFullMask(lsst::afw::image::MaskPixel growFullMask  
    ) {
        _growFullMask = growFullMask;
    }
 
    bool isPersistable() const noexcept override;
 
protected:
    std::string getPersistenceName() const override;
    std::string getPythonModule() const override;
    void write(OutputArchiveHandle &handle) const override;
 
private:
    void _testWarpingKernels(SeparableKernel const &warpingKernel,     
                             SeparableKernel const &maskWarpingKernel  
    ) const;
 
    std::shared_ptr<SeparableKernel> _warpingKernelPtr;
    std::shared_ptr<SeparableKernel> _maskWarpingKernelPtr;
    int _cacheSize;
    int _interpLength;
    lsst::afw::image::MaskPixel _growFullMask;
};
 
template <typename DestExposureT, typename SrcExposureT>
int warpExposure(
        DestExposureT &destExposure,  
        SrcExposureT const &srcExposure,  
        WarpingControl const &control,    
        typename DestExposureT::MaskedImageT::SinglePixel padValue =
                lsst::afw::math::edgePixel<typename DestExposureT::MaskedImageT>(
                        typename lsst::afw::image::detail::image_traits<
                                typename DestExposureT::MaskedImageT>::image_category())
);
 
template <typename DestImageT, typename SrcImageT>
int warpImage(DestImageT &destImage,          
              geom::SkyWcs const &destWcs,    
              SrcImageT const &srcImage,      
              geom::SkyWcs const &srcWcs,     
              WarpingControl const &control,  
              typename DestImageT::SinglePixel padValue = lsst::afw::math::edgePixel<DestImageT>(
                      typename lsst::afw::image::detail::image_traits<DestImageT>::image_category())
);
 
template <typename DestImageT, typename SrcImageT>
int warpImage(DestImageT &destImage, SrcImageT const &srcImage,
              geom::TransformPoint2ToPoint2 const &srcToDest, WarpingControl const &control,
              typename DestImageT::SinglePixel padValue = lsst::afw::math::edgePixel<DestImageT>(
                      typename lsst::afw::image::detail::image_traits<DestImageT>::image_category()));
 
template <typename DestImageT, typename SrcImageT>
int warpCenteredImage(
        DestImageT &destImage,                               
        SrcImageT const &srcImage,                           
        lsst::geom::LinearTransform const &linearTransform,  
        lsst::geom::Point2D const &centerPosition,  
        WarpingControl const &control,              
        typename DestImageT::SinglePixel padValue = lsst::afw::math::edgePixel<DestImageT>(
                typename lsst::afw::image::detail::image_traits<DestImageT>::image_category())
);
 
}  // namespace math
}  // namespace afw
}  // namespace lsst
 
#endif  // !defined(LSST_AFW_MATH_WARPEXPOSURE_H)