BoundedField.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
 
/*
 * LSST Data Management System
 * Copyright 2008-2014 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_BoundedField_h_INCLUDED
#define LSST_AFW_MATH_BoundedField_h_INCLUDED
 
#include "ndarray.h"
 
#include "lsst/base.h"
#include "lsst/geom/Point.h"
#include "lsst/afw/image/Image.h"
#include "lsst/afw/image/MaskedImage.h"
#include "lsst/afw/table/io/Persistable.h"
 
namespace lsst {
namespace afw {
namespace math {

class BoundedField : public table::io::PersistableFacade<BoundedField>, public table::io::Persistable {
public:
    virtual double evaluate(lsst::geom::Point2D const& position) const = 0;

    double evaluate(double x, double y) const { return evaluate(lsst::geom::Point2D(x, y)); }

    virtual ndarray::Array<double, 1, 1> evaluate(ndarray::Array<double const, 1> const& x,
                                                  ndarray::Array<double const, 1> const& y) const;

    virtual double integrate() const;

    virtual double mean() const;

    lsst::geom::Box2I getBBox() const { return _bbox; }

    template <typename T>
    void fillImage(image::Image<T>& image, bool overlapOnly = false, int xStep = 1, int yStep = 1) const;

    template <typename T>
    void addToImage(image::Image<T>& image, double scaleBy = 1.0, bool overlapOnly = false, int xStep = 1,
                    int yStep = 1) const;


    template <typename T>
    void multiplyImage(image::Image<T>& image, bool overlapOnly = false, int xStep = 1, int yStep = 1) const;
 
    template <typename T>
    void multiplyImage(image::MaskedImage<T>& image, bool overlapOnly = false) const;


    template <typename T>
    void divideImage(image::Image<T>& image, bool overlapOnly = false, int xStep = 1, int yStep = 1) const;
 
    template <typename T>
    void divideImage(image::MaskedImage<T>& image, bool overlapOnly = false) const;

    virtual std::shared_ptr<BoundedField> operator*(double const scale) const = 0;
    std::shared_ptr<BoundedField> operator/(double scale) const { return (*this) * (1.0 / scale); }

    virtual bool operator==(BoundedField const& rhs) const = 0;
    bool operator!=(BoundedField const& rhs) const { return !(*this == rhs); };
 
    ~BoundedField() override = default;
    BoundedField(BoundedField const&) = default;
    BoundedField(BoundedField&&) = default;
    BoundedField& operator=(BoundedField const&) = delete;
    BoundedField& operator=(BoundedField&&) = delete;
 
    friend std::ostream& operator<<(std::ostream& os, BoundedField const& bf) {
        return os << bf.toString() << " on " << bf.getBBox();
    }
 
protected:
    explicit BoundedField(lsst::geom::Box2I const& bbox) : _bbox(bbox) {}
 
private:
    lsst::geom::Box2I const _bbox;
 
    // String form of the mathematical component (not including the bbox)
    virtual std::string toString() const = 0;
};
 
std::shared_ptr<BoundedField> operator*(double const scale, std::shared_ptr<BoundedField const> bf);
}  // namespace math
}  // namespace afw
}  // namespace lsst
 
#endif  // !LSST_AFW_MATH_BoundedField_h_INCLUDED