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

namespace lsst {
namespace afw {
namespace image {
template <typename PixelT>
class Image;
template <typename PixelT, typename U, typename V>
class MaskedImage;
}  // namespace image
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>
std::shared_ptr<Approximate<PixelT>> makeApproximate(std::vector<double> const& x,
                                                     std::vector<double> const& y,
                                                     image::MaskedImage<PixelT> const& im,
                                                     lsst::geom::Box2I const& bbox,
                                                     ApproximateControl const& ctrl);

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

    friend std::shared_ptr<Approximate<PixelT>> makeApproximate<>(std::vector<double> const& x,
                                                                  std::vector<double> const& y,
                                                                  image::MaskedImage<PixelT> const& im,
                                                                  lsst::geom::Box2I const& bbox,
                                                                  ApproximateControl const& ctrl);
    Approximate(Approximate const&) = delete;
    Approximate(Approximate&&) = delete;
    Approximate& operator=(Approximate const&) = delete;
    Approximate& operator=(Approximate&&) = delete;

    virtual ~Approximate() = default;
    std::shared_ptr<image::Image<OutPixelT>> getImage(int orderX = -1, int orderY = -1) const {
        return doGetImage(orderX, orderY);
    }
    std::shared_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,   
                lsst::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;  
    lsst::geom::Box2I const _bbox;    
    ApproximateControl const _ctrl;   
private:
    virtual std::shared_ptr<image::Image<OutPixelT>> doGetImage(int orderX, int orderY) const = 0;
    virtual std::shared_ptr<image::MaskedImage<OutPixelT>> doGetMaskedImage(int orderX, int orderY) const = 0;
};
}  // namespace math
}  // namespace afw
}  // namespace lsst

#endif  // LSST_AFW_MATH_APPROXIMATE_H