CcdImage.h

Go to the documentation of this file.

// -*- LSST-C++ -*-
/*
 * This file is part of jointcal.
 *
 * Developed for the LSST Data Management System.
 * This product includes software developed by the LSST Project
 * (https://www.lsst.org).
 * See the COPYRIGHT file at the top-level directory of this distribution
 * for details of code ownership.
 *
 * 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 GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef LSST_JOINTCAL_CCD_IMAGE_H
#define LSST_JOINTCAL_CCD_IMAGE_H

#include <list>
#include <string>

#include "lsst/afw/cameraGeom/Detector.h"
#include "lsst/afw/table/Source.h"
#include "lsst/afw/geom/SkyWcs.h"
#include "lsst/afw/image/PhotoCalib.h"
#include "lsst/afw/image/VisitInfo.h"
#include "lsst/daf/base/PropertySet.h"
#include "lsst/geom/Box.h"
#include "lsst/geom/SpherePoint.h"
#include "lsst/jointcal/MeasuredStar.h"
#include "lsst/jointcal/AstrometryTransform.h"
#include "lsst/jointcal/Frame.h"

namespace lsst {
namespace jointcal {

typedef std::list<std::shared_ptr<CcdImage>> CcdImageList;

typedef int VisitIdType;
typedef int CcdIdType;
struct CcdImageKey {
    VisitIdType visit;
    CcdIdType ccd;
    bool operator!=(CcdImageKey const &right) const { return !(*this == right); }
    bool operator==(CcdImageKey const &right) const { return (visit == right.visit) && (ccd == right.ccd); }
};
// typedef std::pair<VisitIdType, CcdIdType> CcdImageKey;
std::ostream &operator<<(std::ostream &out, CcdImageKey const &key);

class CcdImage {
public:
    CcdImage(afw::table::SourceCatalog &record, std::shared_ptr<lsst::afw::geom::SkyWcs> wcs,
             std::shared_ptr<lsst::afw::image::VisitInfo> visitInfo, lsst::geom::Box2I const &bbox,
             std::string const &filter, std::shared_ptr<afw::image::PhotoCalib> photoCalib,
             std::shared_ptr<afw::cameraGeom::Detector> detector, int visit, int ccd,
             std::string const &fluxField);

    CcdImage(CcdImage const &) = delete;
    CcdImage(CcdImage &&) = delete;
    CcdImage &operator=(CcdImage const &) = delete;
    CcdImage &operator=(CcdImage &&) = delete;

    std::string getName() const { return _name; }

    MeasuredStarList const &getWholeCatalog() const { return _wholeCatalog; }


    MeasuredStarList const &getCatalogForFit() const { return _catalogForFit; }
    MeasuredStarList &getCatalogForFit() { return _catalogForFit; }

    void resetCatalogForFit() {
        getCatalogForFit().clear();
        getWholeCatalog().copyTo(getCatalogForFit());
    }

    std::pair<int, int> countStars() const;

    void setCommonTangentPoint(Point const &commonTangentPoint);

    jointcal::Point const &getCommonTangentPoint() const { return _commonTangentPoint; }

    std::shared_ptr<AstrometryTransform> const getPixelToCommonTangentPlane() const {
        return _pixelToCommonTangentPlane;
    }

    std::shared_ptr<AstrometryTransform> const getCommonTangentPlaneToTangentPlane() const {
        return _commonTangentPlaneToTangentPlane;
    }

    std::shared_ptr<AstrometryTransform> const getTangentPlaneToCommonTangentPlane() const {
        return _tangentPlaneToCommonTangentPlane;
    }

    std::shared_ptr<AstrometryTransform> const getPixelToTangentPlane() const { return _pixelToTangentPlane; }

    std::shared_ptr<AstrometryTransform> const getSkyToTangentPlane() const { return _skyToTangentPlane; }

    CcdIdType getCcdId() const { return _ccdId; }

    VisitIdType getVisit() const { return _visit; }

    std::shared_ptr<afw::cameraGeom::Detector> getDetector() const { return _detector; }

    CcdImageKey getHashKey() const { return CcdImageKey{_visit, _ccdId}; }

    double getAirMass() const { return _airMass; }

    double getMjd() const { return _mjd; }

    std::shared_ptr<afw::image::PhotoCalib> getPhotoCalib() const { return _photoCalib; }

    lsst::geom::SpherePoint getBoresightRaDec() const { return _boresightRaDec; }

    double getHourAngle() const { return _hourAngle; }

    double getLstObs() const { return _lstObs; }

    double getSinEta() const { return _sinEta; }

    double getCosEta() const { return _cosEta; }

    double getTanZ() const { return _tanZ; }

    Point getRefractionVector() const { return Point(_tanZ * _cosEta, _tanZ * _sinEta); }

    std::string getFilter() const { return _filter; }

    std::shared_ptr<AstrometryTransform> const getReadWcs() const { return _readWcs; }

    Frame const &getImageFrame() const { return _imageFrame; }

private:
    void loadCatalog(lsst::afw::table::SortedCatalogT<lsst::afw::table::SourceRecord> const &Cat,
                     std::string const &fluxField);

    jointcal::Frame _imageFrame;  // in pixels

    MeasuredStarList _wholeCatalog;  // the catalog of measured objets
    MeasuredStarList _catalogForFit;

    std::shared_ptr<AstrometryTransformSkyWcs> _readWcs;  // apply goes from pix to sky

    // The following ones should probably be mostly removed.
    // go from CommonTangentPlane to this tangent plane.
    std::shared_ptr<AstrometryTransform> _commonTangentPlaneToTangentPlane;
    std::shared_ptr<AstrometryTransform> _tangentPlaneToCommonTangentPlane;  // reverse one
    std::shared_ptr<AstrometryTransform> _pixelToCommonTangentPlane;         // pixels -> CTP
    std::shared_ptr<AstrometryTransform> _pixelToTangentPlane;

    std::shared_ptr<AstrometryTransform> _skyToTangentPlane;

    std::string _name;
    CcdIdType _ccdId;
    VisitIdType _visit;

    lsst::geom::SpherePoint _boresightRaDec;
    double _airMass;  // airmass value.
    double _mjd;      // modified julian date
    std::shared_ptr<afw::image::PhotoCalib> _photoCalib;
    std::shared_ptr<afw::cameraGeom::Detector> _detector;
    // refraction
    // eta : parallactic angle, z: zenithal angle (X = 1/cos(z))
    double _sinEta, _cosEta, _tanZ;
    // Local Sidereal Time and hour angle of observation
    double _lstObs, _hourAngle;

    std::string _filter;

    jointcal::Point _commonTangentPoint;
};
}  // namespace jointcal
}  // namespace lsst

// Add our preferred hash of CcdImageKey to the std:: namespace, so it's always available "for free".
namespace std {
template <>
struct hash<lsst::jointcal::CcdImageKey> {
    size_t operator()(lsst::jointcal::CcdImageKey const &key) const {
        return hash<size_t>()(static_cast<size_t>(key.visit) | (static_cast<size_t>(key.ccd) << 32));
    }
};
}  // namespace std

#endif  // LSST_JOINTCAL_CCD_IMAGE_H