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"

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 boost::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); 

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

    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 Key< Point<int> > getBBoxMinKey() { return getMinimalSchema().bboxMin; }
    static Key< Point<int> > getBBoxExtentKey() { return getMinimalSchema().bboxExtent; }
    static Key<double> getGainKey() { return getMinimalSchema().gain; }
    static Key<double> getReadNoiseKey() { return getMinimalSchema().readNoise; }
    static Key<int> getSaturationKey() { return getMinimalSchema().saturation; }
    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 Key< Point<int> > getRawBBoxMinKey() { return getMinimalSchema().rawBBoxMin; }
    static Key< Point<int> > getRawBBoxExtentKey() { return getMinimalSchema().rawBBoxExtent; }
    static Key< Point<int> > getRawDataBBoxMinKey() { return getMinimalSchema().rawDataBBoxMin; }
    static Key< Point<int> > getRawDataBBoxExtentKey() { return getMinimalSchema().rawDataBBoxExtent; }
    static Key<Flag> getRawFlipXKey() { return getMinimalSchema().rawFlipX; }
    static Key<Flag> getRawFlipYKey() { return getMinimalSchema().rawFlipY; }
    static Key< Point<int> > getRawXYOffsetKey() { return getMinimalSchema().rawXYOffset; }
    static Key< Point<int> > getRawHorizontalOverscanBBoxMinKey() { return getMinimalSchema().rawHorizontalOverscanBBoxMin; }
    static Key< Point<int> > getRawHorizontalOverscanBBoxExtentKey() { return getMinimalSchema().rawHorizontalOverscanBBoxExtent; }
    static Key< Point<int> > getRawVerticalOverscanBBoxMinKey() { return getMinimalSchema().rawVerticalOverscanBBoxMin; }
    static Key< Point<int> > getRawVerticalOverscanBBoxExtentKey() { return getMinimalSchema().rawVerticalOverscanBBoxExtent; }
    static Key< Point<int> > getRawPrescanBBoxMinKey() { return getMinimalSchema().rawPrescanBBoxMin; }
    static Key< Point<int> > getRawPrescanBBoxExtentKey() { return getMinimalSchema().rawPrescanBBoxExtent; }

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

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

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

    PTR(AmpInfoRecord) copyRecord(BaseRecord const & other, SchemaMapper const & mapper) {
        return boost::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;
        Key< Point<int> > bboxMin;
        Key< Point<int> > bboxExtent;
        Key<double> gain;
        Key<double> readNoise;
        Key<int> saturation;
        Key<int> readoutCorner;
        Key< Array<double> > linearityCoeffs;
        Key<std::string> linearityType;
        Key<Flag> hasRawInfo;
        Key< Point<int> > rawBBoxMin;
        Key< Point<int> > rawBBoxExtent;
        Key< Point<int> > rawDataBBoxMin;
        Key< Point<int> > rawDataBBoxExtent;
        Key<Flag> rawFlipX;
        Key<Flag> rawFlipY;
        Key< Point<int> > rawXYOffset;
        Key< Point<int> > rawHorizontalOverscanBBoxMin;
        Key< Point<int> > rawHorizontalOverscanBBoxExtent;
        Key< Point<int> > rawVerticalOverscanBBoxMin;
        Key< Point<int> > rawVerticalOverscanBBoxExtent;
        Key< Point<int> > rawPrescanBBoxMin;
        Key< Point<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