FootprintSet.h

Go to the documentation of this file.

//  -*- lsst-c++ -*-
/*
 * 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/>.
 */
 
#if !defined(LSST_DETECTION_FOOTPRINT_SET_H)
#define LSST_DETECTION_FOOTPRINT_SET_H
/*
 * Represent a collections of footprints associated with image data
 */
#include <cstdint>
 
#include "lsst/geom.h"
#include "lsst/afw/detection/Threshold.h"
#include "lsst/afw/detection/Footprint.h"
#include "lsst/afw/detection/FootprintCtrl.h"
#include "lsst/afw/detection/Peak.h"
#include "lsst/afw/image/MaskedImage.h"
#include "lsst/afw/table/Source.h"
#include "lsst/afw/table/Schema.h"
 
namespace lsst {
namespace afw {
namespace detection {
 
using FootprintIdPixel = std::uint64_t;
 
class FootprintSet {
public:
    using FootprintList = std::vector<std::shared_ptr<Footprint>>;
 
    template <typename ImagePixelT>
    FootprintSet(image::Image<ImagePixelT> const& img, Threshold const& threshold, int const npixMin = 1,
                 bool const setPeaks = true,
                 table::Schema const& peakSchema = PeakTable::makeMinimalSchema());
 
    template <typename MaskPixelT>
    FootprintSet(image::Mask<MaskPixelT> const& img, Threshold const& threshold, int const npixMin = 1);
 
    template <typename ImagePixelT, typename MaskPixelT>
    FootprintSet(image::MaskedImage<ImagePixelT, MaskPixelT> const& img, Threshold const& threshold,
                 std::string const& planeName = "", int const npixMin = 1, bool const setPeaks = true);
 
    FootprintSet(lsst::geom::Box2I region);
    FootprintSet(FootprintSet const& rhs);
    FootprintSet(FootprintSet const& set, int rGrow, FootprintControl const& ctrl);
    FootprintSet(FootprintSet&& rhs);
    ~FootprintSet();
    FootprintSet(FootprintSet const& set, int rGrow, bool isotropic = true);
    FootprintSet(FootprintSet const& footprints1, FootprintSet const& footprints2, bool const includePeaks);
 
    FootprintSet& operator=(FootprintSet const& rhs);
    FootprintSet& operator=(FootprintSet&& rhs);
 
    void swap(FootprintSet& rhs) noexcept {
        using std::swap;  // See Meyers, Effective C++, Item 25
        swap(*_footprints, *rhs.getFootprints());
        lsst::geom::Box2I rhsRegion = rhs.getRegion();
        rhs.setRegion(getRegion());
        setRegion(rhsRegion);
    }
 
    void swapFootprintList(FootprintList& rhs) noexcept {
        using std::swap;
        swap(*_footprints, rhs);
    }
 
    std::shared_ptr<FootprintList> getFootprints() { return _footprints; }
 
    void setFootprints(std::shared_ptr<FootprintList> footprints) { _footprints = footprints; }
 
    std::shared_ptr<FootprintList const> const getFootprints() const { return _footprints; }
 
    void makeSources(afw::table::SourceCatalog& catalog) const;
 
    void setRegion(lsst::geom::Box2I const& region);
 
    lsst::geom::Box2I const getRegion() const { return _region; }
 
    std::shared_ptr<image::Image<FootprintIdPixel>> insertIntoImage() const;
 
    template <typename MaskPixelT>
    void setMask(image::Mask<MaskPixelT>* mask,  
                 std::string const& planeName    
    ) {
        for (auto const& foot : *_footprints) {
            foot->getSpans()->setMask(*mask, image::Mask<MaskPixelT>::getPlaneBitMask(planeName));
        }
    }
 
    template <typename MaskPixelT>
    void setMask(std::shared_ptr<image::Mask<MaskPixelT>> mask,  
                 std::string const& planeName                    
    ) {
        setMask(mask.get(), planeName);
    }
 
    void merge(FootprintSet const& rhs, int tGrow = 0, int rGrow = 0, bool isotropic = true);
 
    template <typename ImagePixelT, typename MaskPixelT>
    void makeHeavy(image::MaskedImage<ImagePixelT, MaskPixelT> const& mimg,
                   HeavyFootprintCtrl const* ctrl = nullptr);
 
private:
    std::shared_ptr<FootprintList> _footprints;  
    lsst::geom::Box2I _region;  
};
 
std::ostream& operator<<(std::ostream& os, FootprintSet const& rhs);
 
}  // namespace detection
}  // namespace afw
}  // namespace lsst
 
#endif