AmpInfo.h

Go to the documentation of this file.

// -*- lsst-c++ -*-
/*
 * LSST Data Management System
 * Copyright 2008, 2009, 2010, 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_AmpInfo_h_INCLUDED
#define AFW_TABLE_AmpInfo_h_INCLUDED

#include "lsst/afw/table/BaseRecord.h"
#include "lsst/afw/table/BaseTable.h"
#include "lsst/afw/table/Catalog.h"
#include "lsst/afw/table/BaseColumnView.h"
#include "lsst/afw/table/aggregates.h"

namespace lsst { namespace afw { namespace table {

enum ReadoutCorner {
    LL,
    LR,
    UR,
    UL,
};


class AmpInfoRecord;
class AmpInfoTable;

class AmpInfoRecord : public BaseRecord {
public:

    typedef AmpInfoTable Table;
    typedef ColumnViewT<AmpInfoRecord> ColumnView;
    typedef CatalogT<AmpInfoRecord> Catalog;
    typedef CatalogT<AmpInfoRecord const> ConstCatalog;

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

    std::string getName() const;
    void setName(std::string const &name); 

    geom::Box2I getBBox() const;
    void setBBox(geom::Box2I const &bbox); 

    double getGain() const;
    void setGain(double gain); 

    double getReadNoise() const;
    void setReadNoise(double readNoise); 

    double getSaturation() const;
    void setSaturation(double saturation); 

    double getSuspectLevel() const;
    void setSuspectLevel(double suspectLevel); 

    ReadoutCorner getReadoutCorner() const;
    void setReadoutCorner(ReadoutCorner val); 

    std::vector<double> getLinearityCoeffs() const;
    void setLinearityCoeffs(std::vector<double> const &coeffs); 

    std::string getLinearityType() const;
    void setLinearityType(std::string const &type); 

    bool getHasRawInfo() const;
    void setHasRawInfo(bool hasRawInfo); 

    geom::Box2I getRawBBox() const;
    void setRawBBox(geom::Box2I const &bbox); 

    geom::Box2I getRawDataBBox() const;
    void setRawDataBBox(geom::Box2I const &bbox); 

    bool getRawFlipX() const;
    void setRawFlipX(bool rawFlipX);  

    bool getRawFlipY() const;
    void setRawFlipY(bool rawFlipY); 

    geom::Extent2I getRawXYOffset() const;
    void setRawXYOffset(geom::Extent2I const &xy); 

    geom::Box2I getRawHorizontalOverscanBBox() const;
    void setRawHorizontalOverscanBBox(geom::Box2I const &bbox); 

    geom::Box2I getRawVerticalOverscanBBox() const;
    void setRawVerticalOverscanBBox(geom::Box2I const &bbox); 

    geom::Box2I getRawPrescanBBox() const;
    void setRawPrescanBBox(geom::Box2I const &bbox); 


protected:

    AmpInfoRecord(PTR(AmpInfoTable) const & table);

};

class AmpInfoTable : public BaseTable {
public:

    typedef AmpInfoRecord Record;
    typedef ColumnViewT<AmpInfoRecord> ColumnView;
    typedef CatalogT<Record> Catalog;
    typedef CatalogT<Record const> ConstCatalog;
    static int const MAX_NAME_LENGTH = 64; // max length for amplifier name
    static int const MAX_LINEARITY_COEFFS = 4;  // max number of linearity coefficients
    static int const MAX_LINEARITY_TYPE_LENGTH = 64; // max length for linearity type

    static PTR(AmpInfoTable) make(Schema const & schema);

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

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


    static Key<std::string> getNameKey() { return getMinimalSchema().name; }
    static PointKey<int> getBBoxMinKey() { return getMinimalSchema().bboxMin; }
    static PointKey<int> getBBoxExtentKey() { return getMinimalSchema().bboxExtent; }
    static Key<double> getGainKey() { return getMinimalSchema().gain; }
    static Key<double> getReadNoiseKey() { return getMinimalSchema().readNoise; }
    static Key<double> getSaturationKey() { return getMinimalSchema().saturation; }
    static Key<double> getSuspectLevelKey() { return getMinimalSchema().suspectLevel; }
    static Key<int> getReadoutCornerKey() { return getMinimalSchema().readoutCorner; }
    static Key< Array<double> > getLinearityCoeffsKey() { return getMinimalSchema().linearityCoeffs; }
    static Key<std::string> getLinearityTypeKey() { return getMinimalSchema().linearityType; }
    static Key<Flag> getHasRawInfoKey() { return getMinimalSchema().hasRawInfo; }
    static PointKey<int> getRawBBoxMinKey() { return getMinimalSchema().rawBBoxMin; }
    static PointKey<int> getRawBBoxExtentKey() { return getMinimalSchema().rawBBoxExtent; }
    static PointKey<int> getRawDataBBoxMinKey() { return getMinimalSchema().rawDataBBoxMin; }
    static PointKey<int> getRawDataBBoxExtentKey() { return getMinimalSchema().rawDataBBoxExtent; }
    static Key<Flag> getRawFlipXKey() { return getMinimalSchema().rawFlipX; }
    static Key<Flag> getRawFlipYKey() { return getMinimalSchema().rawFlipY; }
    static PointKey<int> getRawXYOffsetKey() { return getMinimalSchema().rawXYOffset; }
    static PointKey<int> getRawHorizontalOverscanBBoxMinKey() { return getMinimalSchema().rawHorizontalOverscanBBoxMin; }
    static PointKey<int> getRawHorizontalOverscanBBoxExtentKey() { return getMinimalSchema().rawHorizontalOverscanBBoxExtent; }
    static PointKey<int> getRawVerticalOverscanBBoxMinKey() { return getMinimalSchema().rawVerticalOverscanBBoxMin; }
    static PointKey<int> getRawVerticalOverscanBBoxExtentKey() { return getMinimalSchema().rawVerticalOverscanBBoxExtent; }
    static PointKey<int> getRawPrescanBBoxMinKey() { return getMinimalSchema().rawPrescanBBoxMin; }
    static PointKey<int> getRawPrescanBBoxExtentKey() { return getMinimalSchema().rawPrescanBBoxExtent; }

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

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

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

    PTR(AmpInfoRecord) copyRecord(BaseRecord const & other, SchemaMapper const & mapper) {
        return std::static_pointer_cast<AmpInfoRecord>(BaseTable::copyRecord(other, mapper));
    }

protected:

    AmpInfoTable(Schema const & schema);

    AmpInfoTable(AmpInfoTable const & other);

private:

    // Struct that holds the minimal schema and the special keys we've added to it.
    struct MinimalSchema {
        Schema schema;
        Key<std::string> name;
        PointKey<int> bboxMin;
        PointKey<int> bboxExtent;
        Key<double> gain;
        Key<double> readNoise;
        Key<double> saturation;
        Key<double> suspectLevel;
        Key<int> readoutCorner;
        Key< Array<double> > linearityCoeffs;
        Key<std::string> linearityType;
        Key<Flag> hasRawInfo;
        PointKey<int> rawBBoxMin;
        PointKey<int> rawBBoxExtent;
        PointKey<int> rawDataBBoxMin;
        PointKey<int> rawDataBBoxExtent;
        Key<Flag> rawFlipX;
        Key<Flag> rawFlipY;
        PointKey<int> rawXYOffset;
        PointKey<int> rawHorizontalOverscanBBoxMin;
        PointKey<int> rawHorizontalOverscanBBoxExtent;
        PointKey<int> rawVerticalOverscanBBoxMin;
        PointKey<int> rawVerticalOverscanBBoxExtent;
        PointKey<int> rawPrescanBBoxMin;
        PointKey<int> rawPrescanBBoxExtent;
        MinimalSchema();
    };

    // Return the singleton minimal schema.
    static MinimalSchema & getMinimalSchema();

    friend class io::FitsWriter;

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

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

#endif // !AFW_TABLE_AmpInfo_h_INCLUDED