lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory Class Reference

Inheritance diagram for lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory:

Public Member Functions
	Factory (std::string const &name)
std::shared_ptr< afw::table::io::Persistable >	read (InputArchive const &archive, CatalogVector const &catalogs) const override
	Construct a new object from the given InputArchive and vector of catalogs. More...

Static Public Member Functions
static PersistableFactory const &	lookup (std::string const &name, std::string const &module="")
	Return the factory that has been registered with the given name. More...

Static Public Attributes
static Factory	registration

Protected Types
using	InputArchive = io::InputArchive
using	CatalogVector = io::CatalogVector

Detailed Description

template<typename ImagePixelT, typename MaskPixelT = lsst::afw::image::MaskPixel, typename VariancePixelT = lsst::afw::image::VariancePixel>
class lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory

Definition at line 282 of file HeavyFootprint.cc.

Member Typedef Documentation

CatalogVector

using lsst::afw::table::io::PersistableFactory::CatalogVector = io::CatalogVector

protectedinherited

Definition at line 231 of file Persistable.h.

InputArchive

using lsst::afw::table::io::PersistableFactory::InputArchive = io::InputArchive

protectedinherited

Definition at line 230 of file Persistable.h.

Constructor & Destructor Documentation

Factory()

template<typename ImagePixelT , typename MaskPixelT = lsst::afw::image::MaskPixel, typename VariancePixelT = lsst::afw::image::VariancePixel>

lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory::Factory ( std::string const &  name )

inlineexplicit

Definition at line 285 of file HeavyFootprint.cc.

: afw::table::io::PersistableFactory(name) {}

Member Function Documentation

lookup()

PersistableFactory const & lsst::afw::table::io::PersistableFactory::lookup ( std::string const &  name, std::string const &  module = ""  )

staticinherited

Return the factory that has been registered with the given name.

If the lookup fails and module is not an empty string, we will attempt to import a Python module with that name (this will only work when the C++ is being called from Python) and try again.

Definition at line 76 of file Persistable.cc.

                                                                                                   {
    RegistryMap::const_iterator i = getRegistry().find(name);
    if (i == getRegistry().end()) {
        if (!module.empty()) {
            bool success = base::ModuleImporter::import(module);
            if (!success) {
                throw LSST_EXCEPT(
                        pex::exceptions::NotFoundError,
                        (boost::format(
                                 "PersistableFactory with name '%s' not found, and import of module "
                                 "'%s' failed (possibly because Python calls were not available from C++).") %
                         name % module)
                                .str());
            }
            i = getRegistry().find(name);
            if (i == getRegistry().end()) {
                throw LSST_EXCEPT(
                        pex::exceptions::LogicError,
                        (boost::format(
                                 "PersistableFactory with name '%s' not found even after successful import "
                                 "of module '%s'.  Please report this as a bug in the persistence "
                                 "implementation for this object.") %
                         name % module)
                                .str());
            }
        } else {
            throw LSST_EXCEPT(
                    pex::exceptions::LogicError,
                    (boost::format(
                             "PersistableFactory with name '%s' not found, and no Python module to import "
                             "was provided.  Please report this as a bug in the persistence implementation "
                             "for this object.") %
                     name)
                            .str());
        }
    }
    return *i->second;
}

read()

template<typename ImagePixelT , typename MaskPixelT = lsst::afw::image::MaskPixel, typename VariancePixelT = lsst::afw::image::VariancePixel>

std::shared_ptr<afw::table::io::Persistable> lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory::read ( InputArchive const &  archive, CatalogVector const &  catalogs  ) const

inlineoverridevirtual

Construct a new object from the given InputArchive and vector of catalogs.

Implements lsst::afw::table::io::PersistableFactory.

Definition at line 287 of file HeavyFootprint.cc.

                                                                                                    {
        HeavyFootprintPersistenceHelper<ImagePixelT, MaskPixelT, VariancePixelT> const& keys =
                HeavyFootprintPersistenceHelper<ImagePixelT, MaskPixelT, VariancePixelT>::get();
        HeavyFootprintPersistenceHelper<ImagePixelT, std::uint16_t, VariancePixelT> const& legacyKeys =
                HeavyFootprintPersistenceHelper<ImagePixelT, std::uint16_t, VariancePixelT>::get();
        LSST_ARCHIVE_ASSERT(catalogs.size() == 3u);
 
        // Read in the SpanSet into a new Footprint object
        std::shared_ptr<Footprint> loadedFootprint = readSpanSet(catalogs[0], archive);
        // Now read in the PeakCatalog records
        readPeaks(catalogs[1], *loadedFootprint);
        afw::table::BaseRecord const& record = catalogs[2].front();
 
        // Create the HeavyFootprint from the above Footprint
        auto result =
                std::make_shared<HeavyFootprint<ImagePixelT, MaskPixelT, VariancePixelT>>(*loadedFootprint);
        result->_image = ndarray::const_array_cast<ImagePixelT>(record.get(keys.image));
 
        // Handle legacy Masks prior to change to int32
        if (catalogs[2].getSchema() == legacyKeys.schema) {
            auto legacyMask = ndarray::const_array_cast<std::uint16_t>(record.get(legacyKeys.mask));
            result->_mask.deep() = legacyMask;
        } else {
            result->_mask = ndarray::const_array_cast<MaskPixelT>(record.get(keys.mask));
        }
        result->_variance = ndarray::const_array_cast<VariancePixelT>(record.get(keys.variance));
        return result;
    }

Member Data Documentation

registration

template<typename ImagePixelT , typename MaskPixelT , typename VariancePixelT >

HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory lsst::afw::detection::HeavyFootprint< ImagePixelT, MaskPixelT, VariancePixelT >::Factory::registration

static

Definition at line 317 of file HeavyFootprint.cc.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/src/detection/HeavyFootprint.cc