astrometry_net.h

Go to the documentation of this file.

// -*- lsst-C++ -*-

// Astrometry.net include files...
extern "C" {
#include "astrometry/solver.h"
#include "astrometry/index.h"
#include "astrometry/multiindex.h"
#include "astrometry/starkd.h"
#include "astrometry/fitsioutils.h"
#include "astrometry/fitstable.h"
#include "astrometry/log.h"
#include "astrometry/tic.h"
#include "astrometry/healpix.h"

#undef ATTRIB_FORMAT
#undef FALSE
#undef TRUE

#undef logdebug
#undef debug
}

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "boost/format.hpp"

#include "lsst/utils/python.h"
#include "lsst/meas/extensions/astrometryNet/detail/utils.h"
#include "lsst/base.h"
#include "lsst/log/Log.h"
#include "lsst/daf/persistence.h"
#include "lsst/daf/base/Persistable.h"
#include "lsst/daf/base/PropertyList.h"
#include "lsst/afw/table.h"
#include "lsst/afw/image/Wcs.h"
#include "lsst/afw/image/TanWcs.h"
#include "lsst/afw/geom.h"
#include "lsst/afw/coord.h"

namespace lsst {
namespace meas {
namespace extensions {
namespace astrometryNet {

/*
 * A thin C++ wrapper around astrometry_net's multiindex_t struct.
 *
 * This provide memory management and a few methods used by LSST.
 */
class MultiIndex {

public:

    MultiIndex(std::string const & filepath);

    ~MultiIndex() {}

    index_t * operator[](int i) const {
        return multiindex_get(_multiindex.get(), i);
    }

    void addIndex(std::string const & filepath, bool metadataOnly);

    int isWithinRange(double ra, double dec, double radius_deg);

    void unload() {
        multiindex_unload(_multiindex.get());
    }

    std::string getName() const {
        return _multiindex->fits->filename;
    }

    int getLength() const {
        return multiindex_n(_multiindex.get());
    }

    void reload();

private:
    
    struct _Deleter {
        void operator()(multiindex_t* m) {
            multiindex_free(m);
        }
    };

    std::unique_ptr<multiindex_t, _Deleter> _multiindex;
};


class Solver {

public:

    explicit Solver();

    ~Solver();

    lsst::afw::table::SimpleCatalog getCatalog(
        std::vector<index_t*> inds,
        lsst::afw::coord::Coord const &ctrCoord,
        lsst::afw::geom::Angle const &radius,
        const char* idCol,
        std::vector<std::string> const& filterNameList,
        std::vector<std::string> const& magColList,
        std::vector<std::string> const& magErrColList,
        const char* starGalCol,
        const char* varCol,
        bool uniqueIds=true);

    std::shared_ptr<lsst::daf::base::PropertyList> getSolveStats() const;

    std::shared_ptr<lsst::afw::image::Wcs> getWcs();

    bool didSolve() const {
        return solver_did_solve(_solver.get());
    }

    void run(double cpulimit);

    std::pair<double, double> getQuadSizeRangeArcsec() const {
        double qlo,qhi;
        solver_get_quad_size_range_arcsec(_solver.get(), &qlo, &qhi);
        return std::make_pair(qlo, qhi);
    }

    void addIndices(std::vector<index_t*> inds);

    void setParity(bool flipped) {
        _solver->parity = flipped ? PARITY_FLIP : PARITY_NORMAL;
    }

    void setMatchThreshold(double threshold) {
        solver_set_keep_logodds(_solver.get(), threshold);
    }

    void setPixelScaleRange(double low, double high) {
        _solver->funits_lower = low;
        _solver->funits_upper = high;
    }

    void setRaDecRadius(double ra, double dec, double radius_deg) {
        solver_set_radec(_solver.get(), ra, dec, radius_deg);
    }

    void setImageSize(int width, int height);

    void setMaxStars(int maxStars) {
        _solver->endobj = maxStars;
    }

    void setStars(lsst::afw::table::SourceCatalog const & srcs, int x0, int y0);

private:

    struct _Deleter {
        void operator()(solver_t* m) {
            solver_free(m);
        }
    };

    std::unique_ptr<solver_t, _Deleter> _solver;
};

lsst::afw::geom::Angle healpixDistance(int hp, int nside, lsst::afw::coord::Coord const& coord);

}}}}  // namespace lsst::meas::extensions::astrometryNet