ApertureFlux.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * 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 <http://www.lsstcorp.org/LegalNotices/>.
 */

#ifndef LSST_MEAS_BASE_ApertureFlux_h_INCLUDED
#define LSST_MEAS_BASE_ApertureFlux_h_INCLUDED

#include "lsst/pex/config.h"
#include "lsst/afw/image/Exposure.h"
#include "lsst/afw/table/arrays.h"
#include "lsst/meas/base/Algorithm.h"
#include "lsst/meas/base/FluxUtilities.h"
#include "lsst/meas/base/CentroidUtilities.h"
#include "lsst/meas/base/FlagHandler.h"
#include "lsst/meas/base/InputUtilities.h"
#include "lsst/meas/base/Transform.h"

namespace lsst { namespace meas { namespace base {

class ApertureFluxControl {
public:

    ApertureFluxControl();

    LSST_CONTROL_FIELD(
        radii, std::vector<double>,
        "Radius (in pixels) of apertures."
    );

    LSST_CONTROL_FIELD(
        maxSincRadius, double,
        "Maximum radius (in pixels) for which the sinc algorithm should be used instead of the "
        "faster naive algorithm.  For elliptical apertures, this is the minor axis radius."
    );

    LSST_CONTROL_FIELD(
        shiftKernel, std::string,
        "Warping kernel used to shift Sinc photometry coefficients to different center positions"
    );

};


struct ApertureFluxResult;


class ApertureFluxAlgorithm : public SimpleAlgorithm {
public:

    enum FlagBits {
        FAILURE=0,
        APERTURE_TRUNCATED,
        SINC_COEFFS_TRUNCATED,
        N_FLAGS
    };

    typedef ApertureFluxControl Control;

    typedef ApertureFluxResult Result;


    template <typename T>
    static Result computeSincFlux(
        afw::image::Image<T> const & image,
        afw::geom::ellipses::Ellipse const & ellipse,
        Control const & ctrl=Control()
    );
    template <typename T>
    static Result computeSincFlux(
        afw::image::MaskedImage<T> const & image,
        afw::geom::ellipses::Ellipse const & ellipse,
        Control const & ctrl=Control()
    );


    template <typename T>
    static Result computeNaiveFlux(
        afw::image::Image<T> const & image,
        afw::geom::ellipses::Ellipse const & ellipse,
        Control const & ctrl=Control()
    );
    template <typename T>
    static Result computeNaiveFlux(
        afw::image::MaskedImage<T> const & image,
        afw::geom::ellipses::Ellipse const & ellipse,
        Control const & ctrl=Control()
    );


    template <typename T>
    static Result computeFlux(
        afw::image::Image<T> const & image,
        afw::geom::ellipses::Ellipse const & ellipse,
        Control const & ctrl=Control()
    );

    template <typename T>
    static Result computeFlux(
        afw::image::MaskedImage<T> const & image,
        afw::geom::ellipses::Ellipse const & ellipse,
        Control const & ctrl=Control()
    );

    explicit ApertureFluxAlgorithm(
        Control const & ctrl,
        std::string const & name,
        afw::table::Schema & schema,
        daf::base::PropertySet & metadata
    );

    virtual ~ApertureFluxAlgorithm() {}

    virtual void measure(
        afw::table::SourceRecord & record,
        afw::image::Exposure<float> const & exposure
    ) const = 0;

    virtual void fail(
        afw::table::SourceRecord & measRecord,
        MeasurementError * error=NULL
    ) const;

    static std::string makeFieldPrefix(std::string const & name, double radius);

protected:

    void copyResultToRecord(Result const & result, afw::table::SourceRecord & record, int index) const;

    FlagHandler const & getFlagHandler(int index) const { return _keys[index].flags; }

    Control const _ctrl;
    SafeCentroidExtractor _centroidExtractor;

private:

    struct Keys {
        FluxResultKey fluxKey;
        FlagHandler flags;

        Keys(afw::table::Schema & schema, std::string const & prefix, std::string const & doc, bool isSinc);
    };

    std::vector<Keys> _keys;
};


struct ApertureFluxResult : public FluxResult {

    bool getFlag(ApertureFluxAlgorithm::FlagBits bit) const { return _flags[bit]; }

    void setFlag(ApertureFluxAlgorithm::FlagBits bit, bool value=true) { _flags[bit] = value; }

    void unsetFlag(ApertureFluxAlgorithm::FlagBits bit) { _flags[bit] = false; }

private:
    std::bitset<ApertureFluxAlgorithm::N_FLAGS> _flags;
};

class ApertureFluxTransform : public BaseTransform {
public:
    typedef ApertureFluxControl Control;
    ApertureFluxTransform(Control const & ctrl, std::string const & name, afw::table::SchemaMapper & mapper);

    /*
     * @brief Perform transformation from inputCatalog to outputCatalog.
     *
     * @param[in]     inputCatalog   Source of data to be transformed
     * @param[in,out] outputCatalog  Container for transformed results
     * @param[in]     wcs            World coordinate system under which transformation will take place
     * @param[in]     calib          Photometric calibration under which transformation will take place
     * @throws        LengthError    Catalog sizes do not match
     */
    virtual void operator()(afw::table::SourceCatalog const & inputCatalog,
                            afw::table::BaseCatalog & outputCatalog,
                            afw::image::Wcs const & wcs,
                            afw::image::Calib const & calib) const;
private:
    std::vector<MagResultKey> _magKeys;
    Control _ctrl;
};

}}} // namespace lsst::meas::base

#endif // !LSST_MEAS_BASE_ApertureFlux_h_INCLUDED