Source.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008-2014, 2011 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/>.
 */
 
#ifndef AFW_TABLE_Source_h_INCLUDED
#define AFW_TABLE_Source_h_INCLUDED
 
#include "lsst/afw/detection/Footprint.h"
#include "lsst/afw/table/Simple.h"
#include "lsst/afw/table/aggregates.h"
#include "lsst/afw/table/IdFactory.h"
#include "lsst/afw/table/Catalog.h"
#include "lsst/afw/table/BaseColumnView.h"
#include "lsst/afw/table/slots.h"
#include "lsst/afw/table/io/FitsWriter.h"
#include "lsst/afw/table/wcsUtils.h"
 
namespace lsst {
namespace afw {
 
namespace geom {
class SkyWcs;
}  // namespace geom
 
namespace table {

enum SourceFitsFlags {
    SOURCE_IO_NO_FOOTPRINTS = 0x1,       
    SOURCE_IO_NO_HEAVY_FOOTPRINTS = 0x2  
};
 
using Footprint = lsst::afw::detection::Footprint;
 
class SourceRecord;
class SourceTable;
 
template <typename RecordT>
class SourceColumnViewT;

class SourceRecord : public SimpleRecord {
public:
    using Table = SourceTable;
    using ColumnView = SourceColumnViewT<SourceRecord>;
    using Catalog = SortedCatalogT<SourceRecord>;
    using ConstCatalog = SortedCatalogT<const SourceRecord>;

    SourceRecord(ConstructionToken const & token, detail::RecordData && data) :
        SimpleRecord(token, std::move(data))
    {}
 
    std::shared_ptr<Footprint> getFootprint() const { return _footprint; }
 
    void setFootprint(std::shared_ptr<Footprint> const &footprint) { _footprint = footprint; }
 
    std::shared_ptr<SourceTable const> getTable() const {
        return std::static_pointer_cast<SourceTable const>(BaseRecord::getTable());
    }


    RecordId getParent() const;
    void setParent(RecordId id);

    FluxSlotDefinition::MeasValue getPsfInstFlux() const;

    FluxSlotDefinition::ErrValue getPsfInstFluxErr() const;

    bool getPsfFluxFlag() const;

    FluxSlotDefinition::MeasValue getModelInstFlux() const;

    FluxSlotDefinition::ErrValue getModelInstFluxErr() const;

    bool getModelFluxFlag() const;

    FluxSlotDefinition::MeasValue getApInstFlux() const;

    FluxSlotDefinition::ErrValue getApInstFluxErr() const;

    bool getApFluxFlag() const;

    FluxSlotDefinition::MeasValue getGaussianInstFlux() const;

    FluxSlotDefinition::ErrValue getGaussianInstFluxErr() const;

    bool getGaussianFluxFlag() const;

    FluxSlotDefinition::MeasValue getCalibInstFlux() const;

    FluxSlotDefinition::ErrValue getCalibInstFluxErr() const;

    bool getCalibFluxFlag() const;

    CentroidSlotDefinition::MeasValue getCentroid() const;

    CentroidSlotDefinition::ErrValue getCentroidErr() const;

    bool getCentroidFlag() const;

    ShapeSlotDefinition::MeasValue getShape() const;

    ShapeSlotDefinition::ErrValue getShapeErr() const;

    bool getShapeFlag() const;

    double getX() const;

    double getY() const;

    double getIxx() const;

    double getIyy() const;

    double getIxy() const;

    void updateCoord(geom::SkyWcs const &wcs, bool include_covariance = true);

    void updateCoord(geom::SkyWcs const &wcs, PointKey<double> const &key,  bool include_covariance = true);
 
    SourceRecord(const SourceRecord &) = delete;
    SourceRecord &operator=(const SourceRecord &) = delete;
    SourceRecord(SourceRecord &&) = delete;
    SourceRecord &operator=(SourceRecord &&) = delete;
    ~SourceRecord();
 
protected:
 
    virtual void _assign(BaseRecord const &other);
 
private:
    friend class SourceTable;
 
    std::shared_ptr<Footprint> _footprint;
};

class SourceTable : public SimpleTable {
public:
    using Record = SourceRecord;
    using ColumnView = SourceColumnViewT<SourceRecord>;
    using Catalog = SortedCatalogT<Record>;
    using ConstCatalog = SortedCatalogT<const Record>;

    static std::shared_ptr<SourceTable> make(Schema const &schema,
                                             std::shared_ptr<IdFactory> const &idFactory);

    static std::shared_ptr<SourceTable> make(Schema const &schema) {
        return make(schema, IdFactory::makeSimple());
    }

    static Schema makeMinimalSchema() {
        Schema r = getMinimalSchema().schema;
        r.disconnectAliases();
        return r;
    }

    static bool checkSchema(Schema const &other) { return other.contains(getMinimalSchema().schema); }

    static Key<RecordId> getParentKey() { return getMinimalSchema().parent; }

    std::shared_ptr<SourceTable> clone() const { return std::static_pointer_cast<SourceTable>(_clone()); }

    std::shared_ptr<SourceRecord> makeRecord() {
        return std::static_pointer_cast<SourceRecord>(_makeRecord());
    }

    std::shared_ptr<SourceRecord> copyRecord(BaseRecord const &other) {
        return std::static_pointer_cast<SourceRecord>(BaseTable::copyRecord(other));
    }

    std::shared_ptr<SourceRecord> copyRecord(BaseRecord const &other, SchemaMapper const &mapper) {
        return std::static_pointer_cast<SourceRecord>(BaseTable::copyRecord(other, mapper));
    }
 
    FluxSlotDefinition const &getPsfFluxSlot() const { return _slots.defPsfFlux; }

    void definePsfFlux(std::string const &name) {
        getSchema().getAliasMap()->set(getPsfFluxSlot().getAlias(), name);
    }
 
    FluxSlotDefinition const &getModelFluxSlot() const { return _slots.defModelFlux; }

    void defineModelFlux(std::string const &name) {
        getSchema().getAliasMap()->set(getModelFluxSlot().getAlias(), name);
    }
 
    FluxSlotDefinition const &getApFluxSlot() const { return _slots.defApFlux; }

    void defineApFlux(std::string const &name) {
        getSchema().getAliasMap()->set(getApFluxSlot().getAlias(), name);
    }
 
    FluxSlotDefinition const &getGaussianFluxSlot() const { return _slots.defGaussianFlux; }

    void defineGaussianFlux(std::string const &name) {
        getSchema().getAliasMap()->set(getGaussianFluxSlot().getAlias(), name);
    }
 
    FluxSlotDefinition const &getCalibFluxSlot() const { return _slots.defCalibFlux; }

    void defineCalibFlux(std::string const &name) {
        getSchema().getAliasMap()->set(getCalibFluxSlot().getAlias(), name);
    }
 
    CentroidSlotDefinition const &getCentroidSlot() const { return _slots.defCentroid; }

    void defineCentroid(std::string const &name) {
        getSchema().getAliasMap()->set(getCentroidSlot().getAlias(), name);
    }
 
    ShapeSlotDefinition const &getShapeSlot() const { return _slots.defShape; }

    void defineShape(std::string const &name) {
        getSchema().getAliasMap()->set(getShapeSlot().getAlias(), name);
    }
 
    SourceTable &operator=(SourceTable const &) = delete;
    SourceTable &operator=(SourceTable &&) = delete;
 
protected:
    SourceTable(Schema const &schema, std::shared_ptr<IdFactory> const &idFactory);
 
    SourceTable(SourceTable const &other);
 
    void handleAliasChange(std::string const &alias) override;
 
    std::shared_ptr<BaseTable> _clone() const override;
 
    std::shared_ptr<BaseRecord> _makeRecord() override;
 
private:
    // Struct that holds the minimal schema and the special keys we've added to it.
    struct MinimalSchema {
        Schema schema;
        Key<RecordId> parent;
 
        MinimalSchema();
    };
 
    // Return the singleton minimal schema.
    static MinimalSchema &getMinimalSchema();
 
    friend class io::FitsWriter;
    friend class SourceRecord;
 
    // Return a writer object that knows how to save in FITS format.  See also FitsWriter.
    std::shared_ptr<io::FitsWriter> makeFitsWriter(fits::Fits *fitsfile, int flags) const override;
 
    SlotSuite _slots;
};
 
template <typename RecordT>
class SourceColumnViewT : public ColumnViewT<RecordT> {
public:
    using Record = RecordT;
    using Table = typename RecordT::Table;
 
    // See the documentation for BaseColumnView for an explanation of why these
    // accessors *appear* to violate const-correctness.

    ndarray::Array<double, 1> getPsfInstFlux() const {
        return this->operator[](this->getTable()->getPsfFluxSlot().getMeasKey());
    }

    ndarray::Array<double, 1> getPsfInstFluxErr() const {
        return this->operator[](this->getTable()->getPsfFluxSlot().getErrKey());
    }

    ndarray::Array<double, 1> getApInstFlux() const {
        return this->operator[](this->getTable()->getApFluxSlot().getMeasKey());
    }

    ndarray::Array<double, 1> getApInstFluxErr() const {
        return this->operator[](this->getTable()->getApFluxSlot().getErrKey());
    }

    ndarray::Array<double, 1> getModelInstFlux() const {
        return this->operator[](this->getTable()->getModelFluxSlot().getMeasKey());
    }

    ndarray::Array<double, 1> getModelInstFluxErr() const {
        return this->operator[](this->getTable()->getModelFluxSlot().getErrKey());
    }

    ndarray::Array<double, 1> getGaussianInstFlux() const {
        return this->operator[](this->getTable()->getGaussianFluxSlot().getMeasKey());
    }

    ndarray::Array<double, 1> getGaussianInstFluxErr() const {
        return this->operator[](this->getTable()->getGaussianFluxSlot().getErrKey());
    }

    ndarray::Array<double, 1> getCalibInstFlux() const {
        return this->operator[](this->getTable()->getCalibFluxSlot().getMeasKey());
    }

    ndarray::Array<double, 1> getCalibInstFluxErr() const {
        return this->operator[](this->getTable()->getCalibFluxSlot().getErrKey());
    }
 
    ndarray::Array<double, 1> const getX() const {
        return this->operator[](this->getTable()->getCentroidSlot().getMeasKey().getX());
    }
    ndarray::Array<double, 1> const getY() const {
        return this->operator[](this->getTable()->getCentroidSlot().getMeasKey().getY());
    }
 
    ndarray::Array<double, 1> const getIxx() const {
        return this->operator[](this->getTable()->getShapeSlot().getMeasKey().getIxx());
    }
    ndarray::Array<double, 1> const getIyy() const {
        return this->operator[](this->getTable()->getShapeSlot().getMeasKey().getIyy());
    }
    ndarray::Array<double, 1> const getIxy() const {
        return this->operator[](this->getTable()->getShapeSlot().getMeasKey().getIxy());
    }

    template <typename InputIterator>
    static SourceColumnViewT make(std::shared_ptr<Table> const &table, InputIterator first,
                                  InputIterator last) {
        return SourceColumnViewT(BaseColumnView::make(table, first, last));
    }
 
    SourceColumnViewT(SourceColumnViewT const &) = default;
    SourceColumnViewT(SourceColumnViewT &&) = default;
    SourceColumnViewT &operator=(SourceColumnViewT const &) = default;
    SourceColumnViewT &operator=(SourceColumnViewT &&) = default;
    ~SourceColumnViewT() = default;
 
protected:
    explicit SourceColumnViewT(BaseColumnView const &base) : ColumnViewT<RecordT>(base) {}
};
 
using SourceColumnView = SourceColumnViewT<SourceRecord>;
 
inline FluxSlotDefinition::MeasValue SourceRecord::getPsfInstFlux() const {
    return this->get(getTable()->getPsfFluxSlot().getMeasKey());
}
 
inline FluxSlotDefinition::ErrValue SourceRecord::getPsfInstFluxErr() const {
    return this->get(getTable()->getPsfFluxSlot().getErrKey());
}
 
inline bool SourceRecord::getPsfFluxFlag() const {
    return this->get(getTable()->getPsfFluxSlot().getFlagKey());
}
 
inline FluxSlotDefinition::MeasValue SourceRecord::getModelInstFlux() const {
    return this->get(getTable()->getModelFluxSlot().getMeasKey());
}
 
inline FluxSlotDefinition::ErrValue SourceRecord::getModelInstFluxErr() const {
    return this->get(getTable()->getModelFluxSlot().getErrKey());
}
 
inline bool SourceRecord::getModelFluxFlag() const {
    return this->get(getTable()->getModelFluxSlot().getFlagKey());
}
 
inline FluxSlotDefinition::MeasValue SourceRecord::getApInstFlux() const {
    return this->get(getTable()->getApFluxSlot().getMeasKey());
}
 
inline FluxSlotDefinition::ErrValue SourceRecord::getApInstFluxErr() const {
    return this->get(getTable()->getApFluxSlot().getErrKey());
}
 
inline bool SourceRecord::getApFluxFlag() const {
    return this->get(getTable()->getApFluxSlot().getFlagKey());
}
 
inline FluxSlotDefinition::MeasValue SourceRecord::getGaussianInstFlux() const {
    return this->get(getTable()->getGaussianFluxSlot().getMeasKey());
}
 
inline FluxSlotDefinition::ErrValue SourceRecord::getGaussianInstFluxErr() const {
    return this->get(getTable()->getGaussianFluxSlot().getErrKey());
}
 
inline bool SourceRecord::getGaussianFluxFlag() const {
    return this->get(getTable()->getGaussianFluxSlot().getFlagKey());
}
 
inline FluxSlotDefinition::MeasValue SourceRecord::getCalibInstFlux() const {
    return this->get(getTable()->getCalibFluxSlot().getMeasKey());
}
 
inline FluxSlotDefinition::ErrValue SourceRecord::getCalibInstFluxErr() const {
    return this->get(getTable()->getCalibFluxSlot().getErrKey());
}
 
inline bool SourceRecord::getCalibFluxFlag() const {
    return this->get(getTable()->getCalibFluxSlot().getFlagKey());
}
 
inline CentroidSlotDefinition::MeasValue SourceRecord::getCentroid() const {
    return this->get(getTable()->getCentroidSlot().getMeasKey());
}
 
inline CentroidSlotDefinition::ErrValue SourceRecord::getCentroidErr() const {
    return this->get(getTable()->getCentroidSlot().getErrKey());
}
 
inline bool SourceRecord::getCentroidFlag() const {
    return this->get(getTable()->getCentroidSlot().getFlagKey());
}
 
inline ShapeSlotDefinition::MeasValue SourceRecord::getShape() const {
    return this->get(getTable()->getShapeSlot().getMeasKey());
}
 
inline ShapeSlotDefinition::ErrValue SourceRecord::getShapeErr() const {
    return this->get(getTable()->getShapeSlot().getErrKey());
}
 
inline bool SourceRecord::getShapeFlag() const { return this->get(getTable()->getShapeSlot().getFlagKey()); }
 
inline RecordId SourceRecord::getParent() const { return get(SourceTable::getParentKey()); }
inline void SourceRecord::setParent(RecordId id) { set(SourceTable::getParentKey(), id); }
inline double SourceRecord::getX() const { return get(getTable()->getCentroidSlot().getMeasKey().getX()); }
inline double SourceRecord::getY() const { return get(getTable()->getCentroidSlot().getMeasKey().getY()); }
inline double SourceRecord::getIxx() const { return get(getTable()->getShapeSlot().getMeasKey().getIxx()); }
inline double SourceRecord::getIyy() const { return get(getTable()->getShapeSlot().getMeasKey().getIyy()); }
inline double SourceRecord::getIxy() const { return get(getTable()->getShapeSlot().getMeasKey().getIxy()); }
 
}  // namespace table
}  // namespace afw
}  // namespace lsst
 
#endif  // !AFW_TABLE_Source_h_INCLUDED