Approximate.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
#if !defined(LSST_AFW_MATH_APPROXIMATE_H)
#define LSST_AFW_MATH_APPROXIMATE_H

/* 
 * LSST Data Management System
 * Copyright 2008-2015 AURA/LSST.
 * 
 * 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 <https://www.lsstcorp.org/LegalNotices/>.
 */
#include "lsst/base.h"

namespace lsst {
namespace afw {
namespace geom {
    class Box2I;
}
namespace image {
template<typename PixelT> class Image;
template<typename PixelT, typename U, typename V> class MaskedImage;
}
namespace math {
template<typename T> class Approximate;

class ApproximateControl {
public:
    enum Style {
        UNKNOWN = -1,
        CHEBYSHEV,                      
        NUM_STYLES
    };

    ApproximateControl(Style style, int orderX, int orderY=-1, bool weighting=true);
    Style getStyle() const { return _style; }
    void setStyle(Style const style) { _style = style; }
    int getOrderX() const { return _orderX; }
    void setOrderX(int const orderX) { _orderX = orderX; }
    int getOrderY() const { return _orderY; }
    void setOrderY(int const orderY) { _orderY = orderY; }
    bool getWeighting() const { return _weighting; }
    void setWeighting(bool const weighting) { _weighting = weighting; }
private:
    Style _style;
    int _orderX;
    int _orderY;
    bool _weighting;
};

template<typename PixelT>
PTR(Approximate<PixelT>)
makeApproximate(std::vector<double> const &x, std::vector<double> const &y,
                image::MaskedImage<PixelT> const& im, geom::Box2I const& bbox,
                ApproximateControl const& ctrl);

template<typename PixelT>
class Approximate {
public:
    typedef float OutPixelT;            

    friend PTR(Approximate<PixelT>)
    makeApproximate<>(std::vector<double> const &x, std::vector<double> const &y,
                    image::MaskedImage<PixelT> const& im, geom::Box2I const& bbox,
                    ApproximateControl const& ctrl);
    virtual ~Approximate() {}
    PTR(image::Image<OutPixelT>) getImage(int orderX=-1, int orderY=-1) const {
        return doGetImage(orderX, orderY);
    }
    PTR(image::MaskedImage<OutPixelT>) getMaskedImage(int orderX=-1, int orderY=-1) const {
        return doGetMaskedImage(orderX, orderY);
    }
protected:
    Approximate(std::vector<double> const &x,         
                std::vector<double> const &y,         
                geom::Box2I const& bbox,              
                ApproximateControl const& ctrl        
               ) : _xVec(x), _yVec(y), _bbox(bbox), _ctrl(ctrl) {}

    std::vector<double> const _xVec;    
    std::vector<double> const _yVec;    
    geom::Box2I const _bbox;            
    ApproximateControl const _ctrl;     
private:
    Approximate(Approximate const&);
    Approximate& operator=(Approximate const&);
    virtual PTR(image::Image<OutPixelT>) doGetImage(int orderX, int orderY) const = 0;
    virtual PTR(image::MaskedImage<OutPixelT>) doGetMaskedImage(int orderX, int orderY) const = 0;
};

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

#endif // LSST_AFW_MATH_APPROXIMATE_H