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/>.
 */

#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/afw/geom.h"
#include "lsst/afw/gpu/DevicePreference.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"

namespace lsst {
namespace afw {
namespace image {
    class Wcs;
}
namespace math {

    class LanczosWarpingKernel : public SeparableKernel {
    public:
        explicit LanczosWarpingKernel(
            int order 
        )
        :
            SeparableKernel(2 * order, 2 * order,
                LanczosFunction1<Kernel::Pixel>(order), LanczosFunction1<Kernel::Pixel>(order))
        {}

        virtual ~LanczosWarpingKernel() {}

        virtual PTR(Kernel) clone() const;

        int getOrder() const;

    protected:
        virtual void setKernelParameter(unsigned int ind, double value) const;
    };

    class BilinearWarpingKernel : public SeparableKernel {
    public:
        explicit BilinearWarpingKernel()
        :
            SeparableKernel(2, 2, BilinearFunction1(0.0), BilinearFunction1(0.0))
        {}

        virtual ~BilinearWarpingKernel() {}

        virtual PTR(Kernel) clone() const;

        class BilinearFunction1: public Function1<Kernel::Pixel> {
        public:
            typedef PTR(Function1<Kernel::Pixel>) Function1Ptr;

            explicit BilinearFunction1(
                double fracPos)    
            :
                Function1<Kernel::Pixel>(1)
            {
                this->_params[0] = fracPos;
            }
            virtual ~BilinearFunction1() {}

            virtual Function1Ptr clone() const {
                return Function1Ptr(new BilinearFunction1(this->_params[0]));
            }

            virtual Kernel::Pixel operator() (double x) const;

            virtual std::string toString(std::string const& ="") const;
        };

    protected:
        virtual void setKernelParameter(unsigned int ind, double value) const;
    };

    class NearestWarpingKernel : public SeparableKernel {
    public:
        explicit NearestWarpingKernel()
        :
            SeparableKernel(2, 2, NearestFunction1(0.0), NearestFunction1(0.0))
        {}

        virtual ~NearestWarpingKernel() {}

        virtual PTR(Kernel) clone() const;

        class NearestFunction1: public Function1<Kernel::Pixel> {
        public:
            typedef PTR(Function1<Kernel::Pixel>) Function1Ptr;

            explicit NearestFunction1(
                double fracPos)    
            :
                Function1<Kernel::Pixel>(1)
            {
                this->_params[0] = fracPos;
            }
            virtual ~NearestFunction1() {}

            virtual Function1Ptr clone() const {
                return Function1Ptr(new NearestFunction1(this->_params[0]));
            }

            virtual Kernel::Pixel operator() (double x) const;

            virtual std::string toString(std::string const& ="") const;
        };

    protected:
        virtual void setKernelParameter(unsigned int ind, double value) const;
    };

    PTR(SeparableKernel) makeWarpingKernel(std::string name);

    class WarpingControl {
    public:
        explicit WarpingControl(
            std::string const &warpingKernelName,   
            std::string const &maskWarpingKernelName = "",  
            int cacheSize = 0,      
            int interpLength = 0,   
            lsst::afw::gpu::DevicePreference devicePreference = lsst::afw::gpu::DEFAULT_DEVICE_PREFERENCE,
            lsst::afw::image::MaskPixel growFullMask = 0
        ) :
            _warpingKernelPtr(makeWarpingKernel(warpingKernelName)),
            _maskWarpingKernelPtr(),
            _cacheSize(cacheSize),
            _interpLength(interpLength),
            _devicePreference(devicePreference),
            _growFullMask(growFullMask)
        {
            setMaskWarpingKernelName(maskWarpingKernelName);
            _testDevicePreference(_devicePreference, _warpingKernelPtr);
        }


        virtual ~WarpingControl() {};

        int getCacheSize() const { return _cacheSize; };

        void setCacheSize(
            int cacheSize 
        ) { _cacheSize = cacheSize; };

        int getInterpLength() const { return _interpLength; };

        void setInterpLength(
            int interpLength 
        ) { _interpLength = interpLength; };

        lsst::afw::gpu::DevicePreference getDevicePreference() const { return _devicePreference; };

        void setDevicePreference(
            lsst::afw::gpu::DevicePreference devicePreference  
        ) {
            _testDevicePreference(devicePreference, _warpingKernelPtr);
            _devicePreference = devicePreference;
        }

        PTR(SeparableKernel) getWarpingKernel() const;

        void setWarpingKernelName(
            std::string const &warpingKernelName    
        );

        void setWarpingKernel(
            SeparableKernel const &warpingKernel   
        );

        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; }

    private:
        void _testWarpingKernels(
            SeparableKernel const &warpingKernel,       
            SeparableKernel const &maskWarpingKernel    
        ) const;

        void _testDevicePreference(
            lsst::afw::gpu::DevicePreference const &devicePreference,   
            CONST_PTR(SeparableKernel) const &warpingKernelPtr          
        ) const;

        PTR(SeparableKernel) _warpingKernelPtr;
        PTR(SeparableKernel) _maskWarpingKernelPtr;
        int _cacheSize;
        int _interpLength;
        lsst::afw::gpu::DevicePreference _devicePreference; 
        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,                  
        lsst::afw::image::Wcs const &destWcs,   
        SrcImageT const &srcImage,              
        lsst::afw::image::Wcs 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,          
        lsst::afw::geom::XYTransform const &xyTransform, 
        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::afw::geom::LinearTransform const &linearTransform, 
        lsst::afw::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 details {
        template <typename A, typename B>
        bool isSameObject(A const&, B const&) { return false; }

        template <typename A>
        bool isSameObject(A const& a, A const& b) { return &a == &b; }
    }

}}} // lsst::afw::math

#endif // !defined(LSST_AFW_MATH_WARPEXPOSURE_H)