PsfCandidate.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
#if !defined(LSST_MEAS_ALGORITHMS_PSFCANDIDATE_H)
#define LSST_MEAS_ALGORITHMS_PSFCANDIDATE_H
 
/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 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/>.
 */

#include <memory>
#include <vector>
#include <string>
#include <limits>
 
#include "lsst/geom/Point.h"
#include "lsst/afw/image/Exposure.h"
#include "lsst/afw/detection/Psf.h"
#include "lsst/afw/detection/FootprintSet.h"
#include "lsst/afw/table/Source.h"
#include "lsst/afw/math/SpatialCell.h"
 
namespace lsst {
namespace meas {
namespace algorithms {
template <typename PixelT>
class PsfCandidate : public afw::math::SpatialCellImageCandidate {
public:
    typedef std::shared_ptr<PsfCandidate<PixelT>> Ptr;
    typedef std::shared_ptr<const PsfCandidate<PixelT>> ConstPtr;
    typedef std::vector<Ptr> PtrList;
 
    typedef afw::image::MaskedImage<PixelT> MaskedImageT;

    PsfCandidate(std::shared_ptr<afw::table::SourceRecord> const & source,  
                 std::shared_ptr<afw::image::Exposure<PixelT> const>
                         parentExposure  
                 )
            : afw::math::SpatialCellImageCandidate(source->getX(), source->getY()),
              _parentExposure(parentExposure),
              _offsetImage(),
              _source(source),
              _image(nullptr),
              _amplitude(0.0),
              _var(1.0),
              _psfColorValue(std::numeric_limits<double>::quiet_NaN()),
              _psfColorType() {}

    PsfCandidate(std::shared_ptr<afw::table::SourceRecord> const & source,  
                 std::shared_ptr<afw::image::Exposure<PixelT> const>
                         parentExposure,  
                 double xCenter,          
                 double yCenter           
                 )
            : afw::math::SpatialCellImageCandidate(xCenter, yCenter),
              _parentExposure(parentExposure),
              _offsetImage(),
              _source(source),
              _image(nullptr),
              _amplitude(0.0),
              _var(1.0),
              _psfColorValue(std::numeric_limits<double>::quiet_NaN()),
              _psfColorType() {}

    virtual ~PsfCandidate(){};

    double getCandidateRating() const { return _source->getPsfInstFlux(); }

    std::shared_ptr<afw::table::SourceRecord> getSource() const { return _source; }

    double getAmplitude() const { return _amplitude; }

    void setAmplitude(double amplitude) { _amplitude = amplitude; }

    void setPsfColorValue(double psfColorValue) { _psfColorValue = psfColorValue; }

    double getPsfColorValue() const { return _psfColorValue; }

    void setPsfColorType(std::string psfColorType) { _psfColorType = psfColorType; }

    std::string getPsfColorType() const { return _psfColorType; }

    double getVar() const { return _var; }

    void setVar(double var) { _var = var; }
 
    std::shared_ptr<afw::image::MaskedImage<PixelT> const> getMaskedImage() const;
    std::shared_ptr<afw::image::MaskedImage<PixelT> const> getMaskedImage(int width, int height) const;
    std::shared_ptr<afw::image::MaskedImage<PixelT>>
    getOffsetImage(std::string const algorithm, unsigned int buffer) const;

    static int getBorderWidth();

    static void setBorderWidth(int border);

    static void setPixelThreshold(float threshold);

    static float getPixelThreshold();

    static void setMaskBlends(bool doMaskBlends);

    static bool getMaskBlends();
 
private:
    std::shared_ptr<afw::image::Exposure<PixelT> const>
    _parentExposure;  // the %image that the Sources are found in
 
    std::shared_ptr<afw::image::MaskedImage<PixelT>>
    offsetImage(std::shared_ptr<afw::image::MaskedImage<PixelT>> img, std::string const algorithm, unsigned int buffer);
 
    std::shared_ptr<afw::image::MaskedImage<PixelT>>
    extractImage(unsigned int width, unsigned int height) const;
 
    std::shared_ptr<afw::image::MaskedImage<PixelT>> mutable _offsetImage;  // %image offset to put center on a pixel
    std::shared_ptr<afw::table::SourceRecord> _source;                      // the Source itself
 
    mutable std::shared_ptr<afw::image::MaskedImage<PixelT>> _image;  // cutout image to return (cached)
    double _amplitude;   // best-fit amplitude of current PSF model
    double _var;         // variance to use when fitting this candidate
    double _psfColorValue;    // psf color value use when fitting this candidate
    std::string _psfColorType; // psf color type use when fitting this candidate
    static int _border;  // width of border of ignored pixels around _image
    geom::Point2D _xyCenter;
    static int _defaultWidth;
    static float _pixelThreshold;  
    static bool _doMaskBlends;     
};

template <typename PixelT>
std::shared_ptr<PsfCandidate<PixelT>> makePsfCandidate(std::shared_ptr<afw::table::SourceRecord>
                                                               const & source,  
                                                       std::shared_ptr<afw::image::Exposure<PixelT>>
                                                               image  
                                                       ) {
    return std::make_shared<PsfCandidate<PixelT>>(source, image);
}
 
}  // namespace algorithms
}  // namespace meas
}  // namespace lsst
 
#endif