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/>.
 */

// THIS FILE IS AUTOMATICALLY GENERATED from Source.h.m4, AND WILL BE OVERWRITTEN IF EDITED MANUALLY.

#ifndef AFW_TABLE_Source_h_INCLUDED
#define AFW_TABLE_Source_h_INCLUDED

#include "boost/array.hpp"
#include "boost/type_traits/is_convertible.hpp"

#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"

namespace lsst { namespace afw {

namespace image {
class Wcs;
} // namespace image

namespace table {

enum SourceFitsFlags {
    SOURCE_IO_NO_FOOTPRINTS = 0x1,       
    SOURCE_IO_NO_HEAVY_FOOTPRINTS = 0x2  
};

typedef lsst::afw::detection::Footprint Footprint;

class SourceRecord;
class SourceTable;

template <typename RecordT> class SourceColumnViewT;

class SourceRecord : public SimpleRecord {
public:

    typedef SourceTable Table;
    typedef SourceColumnViewT<SourceRecord> ColumnView;
    typedef SortedCatalogT<SourceRecord> Catalog;
    typedef SortedCatalogT<SourceRecord const> ConstCatalog;

    PTR(Footprint) getFootprint() const { return _footprint; }

    void setFootprint(PTR(Footprint) const & footprint) { _footprint = footprint; }

    CONST_PTR(SourceTable) getTable() const {
        return std::static_pointer_cast<SourceTable const>(BaseRecord::getTable());
    }

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

    FluxSlotDefinition::MeasValue getPsfFlux() const;

    FluxSlotDefinition::ErrValue getPsfFluxErr() const;

    bool getPsfFluxFlag() const;

    FluxSlotDefinition::MeasValue getModelFlux() const;

    FluxSlotDefinition::ErrValue getModelFluxErr() const;

    bool getModelFluxFlag() const;

    FluxSlotDefinition::MeasValue getApFlux() const;

    FluxSlotDefinition::ErrValue getApFluxErr() const;

    bool getApFluxFlag() const;

    FluxSlotDefinition::MeasValue getInstFlux() const;

    FluxSlotDefinition::ErrValue getInstFluxErr() const;

    bool getInstFluxFlag() const;

    FluxSlotDefinition::MeasValue getCalibFlux() const;

    FluxSlotDefinition::ErrValue getCalibFluxErr() 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(image::Wcs const & wcs);

    void updateCoord(image::Wcs const & wcs, PointKey<double> const & key);

protected:

    SourceRecord(PTR(SourceTable) const & table);

    virtual void _assign(BaseRecord const & other);

private:
    PTR(Footprint) _footprint;
};

class SourceTable : public SimpleTable {
public:

    typedef SourceRecord Record;
    typedef SourceColumnViewT<SourceRecord> ColumnView;
    typedef SortedCatalogT<Record> Catalog;
    typedef SortedCatalogT<Record const> ConstCatalog;

    static PTR(SourceTable) make(Schema const & schema, PTR(IdFactory) const & idFactory);

    static 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; }

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

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

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

    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);
    }

    std::string getPsfFluxDefinition() const {
        return getSchema().getAliasMap()->get(getPsfFluxSlot().getAlias());
    }

    bool hasPsfFluxSlot() const {
        return getPsfFluxSlot().isValid();
    }

    FluxSlotDefinition::MeasKey getPsfFluxKey() const {
        return getPsfFluxSlot().getMeasKey();
    }

    FluxSlotDefinition::ErrKey getPsfFluxErrKey() const {
        return getPsfFluxSlot().getErrKey();
    }

    Key<Flag> getPsfFluxFlagKey() const {
        return getPsfFluxSlot().getFlagKey();
    }

    
    FluxSlotDefinition const & getModelFluxSlot() const { return _slots.defModelFlux; }

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

    std::string getModelFluxDefinition() const {
        return getSchema().getAliasMap()->get(getModelFluxSlot().getAlias());
    }

    bool hasModelFluxSlot() const {
        return getModelFluxSlot().isValid();
    }

    FluxSlotDefinition::MeasKey getModelFluxKey() const {
        return getModelFluxSlot().getMeasKey();
    }

    FluxSlotDefinition::ErrKey getModelFluxErrKey() const {
        return getModelFluxSlot().getErrKey();
    }

    Key<Flag> getModelFluxFlagKey() const {
        return getModelFluxSlot().getFlagKey();
    }

    
    FluxSlotDefinition const & getApFluxSlot() const { return _slots.defApFlux; }

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

    std::string getApFluxDefinition() const {
        return getSchema().getAliasMap()->get(getApFluxSlot().getAlias());
    }

    bool hasApFluxSlot() const {
        return getApFluxSlot().isValid();
    }

    FluxSlotDefinition::MeasKey getApFluxKey() const {
        return getApFluxSlot().getMeasKey();
    }

    FluxSlotDefinition::ErrKey getApFluxErrKey() const {
        return getApFluxSlot().getErrKey();
    }

    Key<Flag> getApFluxFlagKey() const {
        return getApFluxSlot().getFlagKey();
    }

    
    FluxSlotDefinition const & getInstFluxSlot() const { return _slots.defInstFlux; }

    void defineInstFlux(std::string const & name) {
        getSchema().getAliasMap()->set(getInstFluxSlot().getAlias(), name);
    }

    std::string getInstFluxDefinition() const {
        return getSchema().getAliasMap()->get(getInstFluxSlot().getAlias());
    }

    bool hasInstFluxSlot() const {
        return getInstFluxSlot().isValid();
    }

    FluxSlotDefinition::MeasKey getInstFluxKey() const {
        return getInstFluxSlot().getMeasKey();
    }

    FluxSlotDefinition::ErrKey getInstFluxErrKey() const {
        return getInstFluxSlot().getErrKey();
    }

    Key<Flag> getInstFluxFlagKey() const {
        return getInstFluxSlot().getFlagKey();
    }

    
    FluxSlotDefinition const & getCalibFluxSlot() const { return _slots.defCalibFlux; }

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

    std::string getCalibFluxDefinition() const {
        return getSchema().getAliasMap()->get(getCalibFluxSlot().getAlias());
    }

    bool hasCalibFluxSlot() const {
        return getCalibFluxSlot().isValid();
    }

    FluxSlotDefinition::MeasKey getCalibFluxKey() const {
        return getCalibFluxSlot().getMeasKey();
    }

    FluxSlotDefinition::ErrKey getCalibFluxErrKey() const {
        return getCalibFluxSlot().getErrKey();
    }

    Key<Flag> getCalibFluxFlagKey() const {
        return getCalibFluxSlot().getFlagKey();
    }

    
    CentroidSlotDefinition const & getCentroidSlot() const { return _slots.defCentroid; }

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

    std::string getCentroidDefinition() const {
        return getSchema().getAliasMap()->get(getCentroidSlot().getAlias());
    }

    bool hasCentroidSlot() const {
        return getCentroidSlot().isValid();
    }

    CentroidSlotDefinition::MeasKey getCentroidKey() const {
        return getCentroidSlot().getMeasKey();
    }

    CentroidSlotDefinition::ErrKey getCentroidErrKey() const {
        return getCentroidSlot().getErrKey();
    }

    Key<Flag> getCentroidFlagKey() const {
        return getCentroidSlot().getFlagKey();
    }

    
    ShapeSlotDefinition const & getShapeSlot() const { return _slots.defShape; }

    void defineShape(std::string const & name) {
        getSchema().getAliasMap()->set(getShapeSlot().getAlias(), name);
    }

    std::string getShapeDefinition() const {
        return getSchema().getAliasMap()->get(getShapeSlot().getAlias());
    }

    bool hasShapeSlot() const {
        return getShapeSlot().isValid();
    }

    ShapeSlotDefinition::MeasKey getShapeKey() const {
        return getShapeSlot().getMeasKey();
    }

    ShapeSlotDefinition::ErrKey getShapeErrKey() const {
        return getShapeSlot().getErrKey();
    }

    Key<Flag> getShapeFlagKey() const {
        return getShapeSlot().getFlagKey();
    }


protected:

    SourceTable(Schema const & schema, PTR(IdFactory) const & idFactory);

    SourceTable(SourceTable const & other);

    virtual void handleAliasChange(std::string const & alias);

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.
    virtual PTR(io::FitsWriter) makeFitsWriter(fits::Fits * fitsfile, int flags) const;

    SlotSuite _slots;
};

template <typename RecordT>
class SourceColumnViewT : public ColumnViewT<RecordT> {
public:

    typedef RecordT Record;
    typedef typename RecordT::Table Table;

    // See the documentation for BaseColumnView for an explanation of why these
    // accessors *appear* to violate const-correctness.

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

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

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

    ndarray::Array<double,1> getInstFlux() const {
        return this->operator[](this->getTable()->getInstFluxSlot().getMeasKey());
    }
    ndarray::Array<double,1> getInstFluxErr() const {
        return this->operator[](this->getTable()->getInstFluxSlot().getErrKey());
    }

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


    ndarray::Array<double,1> const getX() const {
        return this->operator[](this->getTable()->getCentroidKey().getX());
    }
    ndarray::Array<double,1> const getY() const {
        return this->operator[](this->getTable()->getCentroidKey().getY());
    }

    ndarray::Array<double,1> const getIxx() const {
        return this->operator[](this->getTable()->getShapeKey().getIxx());
    }
    ndarray::Array<double,1> const getIyy() const {
        return this->operator[](this->getTable()->getShapeKey().getIyy());
    }
    ndarray::Array<double,1> const getIxy() const {
        return this->operator[](this->getTable()->getShapeKey().getIxy());
    }

    template <typename InputIterator>
    static SourceColumnViewT make(PTR(Table) const & table, InputIterator first, InputIterator last) {
        return SourceColumnViewT(BaseColumnView::make(table, first, last));
    }

protected:
    explicit SourceColumnViewT(BaseColumnView const & base) : ColumnViewT<RecordT>(base) {}
};

typedef SourceColumnViewT<SourceRecord> SourceColumnView;

#ifndef SWIG

inline FluxSlotDefinition::MeasValue SourceRecord::getPsfFlux() const {
    return this->get(getTable()->getPsfFluxSlot().getMeasKey());
}

inline FluxSlotDefinition::ErrValue SourceRecord::getPsfFluxErr() const {
    return this->get(getTable()->getPsfFluxSlot().getErrKey());
}

inline bool SourceRecord::getPsfFluxFlag() const {
    return this->get(getTable()->getPsfFluxSlot().getFlagKey());
}

inline FluxSlotDefinition::MeasValue SourceRecord::getModelFlux() const {
    return this->get(getTable()->getModelFluxSlot().getMeasKey());
}

inline FluxSlotDefinition::ErrValue SourceRecord::getModelFluxErr() const {
    return this->get(getTable()->getModelFluxSlot().getErrKey());
}

inline bool SourceRecord::getModelFluxFlag() const {
    return this->get(getTable()->getModelFluxSlot().getFlagKey());
}

inline FluxSlotDefinition::MeasValue SourceRecord::getApFlux() const {
    return this->get(getTable()->getApFluxSlot().getMeasKey());
}

inline FluxSlotDefinition::ErrValue SourceRecord::getApFluxErr() const {
    return this->get(getTable()->getApFluxSlot().getErrKey());
}

inline bool SourceRecord::getApFluxFlag() const {
    return this->get(getTable()->getApFluxSlot().getFlagKey());
}

inline FluxSlotDefinition::MeasValue SourceRecord::getInstFlux() const {
    return this->get(getTable()->getInstFluxSlot().getMeasKey());
}

inline FluxSlotDefinition::ErrValue SourceRecord::getInstFluxErr() const {
    return this->get(getTable()->getInstFluxSlot().getErrKey());
}

inline bool SourceRecord::getInstFluxFlag() const {
    return this->get(getTable()->getInstFluxSlot().getFlagKey());
}

inline FluxSlotDefinition::MeasValue SourceRecord::getCalibFlux() const {
    return this->get(getTable()->getCalibFluxSlot().getMeasKey());
}

inline FluxSlotDefinition::ErrValue SourceRecord::getCalibFluxErr() 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()->getCentroidKey().getX());
}
inline double SourceRecord::getY() const {
    return get(getTable()->getCentroidKey().getY());
}
inline double SourceRecord::getIxx() const {
    return get(getTable()->getShapeKey().getIxx());
}
inline double SourceRecord::getIyy() const {
    return get(getTable()->getShapeKey().getIyy());
}
inline double SourceRecord::getIxy() const {
    return get(getTable()->getShapeKey().getIxy());
}

#endif // !SWIG

}}} // namespace lsst::afw::table

#endif // !AFW_TABLE_Source_h_INCLUDED