ApertureFlux.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2016 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 <array>
#include <string>
#include <vector>
#include <bitset>
 
#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:
    // Structures and routines to manage flaghandler
    static FlagDefinitionList const& getFlagDefinitions();
    static unsigned int const N_FLAGS = 3;
    static FlagDefinition const FAILURE;
    static FlagDefinition const APERTURE_TRUNCATED;
    static FlagDefinition const SINC_COEFFS_TRUNCATED;
 
    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 = nullptr) 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 instFluxKey;
        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(unsigned int index) const { return _flags[index]; }
 
    bool getFlag(std::string const& name) const {
        return _flags[ApertureFluxAlgorithm::getFlagDefinitions().getDefinition(name).number];
    }
 
    void setFlag(unsigned int index, bool value = true) { _flags[index] = value; }
 
    void unsetFlag(unsigned int index) { _flags[index] = 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]     photoCalib     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::geom::SkyWcs const& wcs,
                            afw::image::PhotoCalib const& photoCalib) const;
 
private:
    std::vector<MagResultKey> _magKeys;
    Control _ctrl;
};
 
}  // namespace base
}  // namespace meas
}  // namespace lsst
 
#endif  // !LSST_MEAS_BASE_ApertureFlux_h_INCLUDED