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 "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(PTR(afw::table::SourceRecord) const & source,  
                 CONST_PTR(afw::image::Exposure<PixelT>)
                         parentExposure  
                 )
            : afw::math::SpatialCellImageCandidate(source->getX(), source->getY()),
              _parentExposure(parentExposure),
              _offsetImage(),
              _source(source),
              _image(nullptr),
              _amplitude(0.0),
              _var(1.0) {}

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

    virtual ~PsfCandidate(){};

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

    PTR(afw::table::SourceRecord) getSource() const { return _source; }

    double getAmplitude() const { return _amplitude; }

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

    double getVar() const { return _var; }

    void setVar(double var) { _var = var; }

    CONST_PTR(afw::image::MaskedImage<PixelT>) getMaskedImage() const;
    CONST_PTR(afw::image::MaskedImage<PixelT>) getMaskedImage(int width, int height) const;
    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:
    CONST_PTR(afw::image::Exposure<PixelT>)
    _parentExposure;  // the %image that the Sources are found in

    PTR(afw::image::MaskedImage<PixelT>)
    offsetImage(PTR(afw::image::MaskedImage<PixelT>) img, std::string const algorithm, unsigned int buffer);

    PTR(afw::image::MaskedImage<PixelT>)
    extractImage(unsigned int width, unsigned int height) const;

    PTR(afw::image::MaskedImage<PixelT>) mutable _offsetImage;  // %image offset to put center on a pixel
    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
    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(PTR(afw::table::SourceRecord)
                                                               const & source,  
                                                       PTR(afw::image::Exposure<PixelT>)
                                                               image  
                                                       ) {
    return std::make_shared<PsfCandidate<PixelT>>(source, image);
}

}  // namespace algorithms
}  // namespace meas
}  // namespace lsst

#endif