StarMatch.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_STAR_MATCH_H
#define LSST_JOINTCAL_STAR_MATCH_H
 
#include <iostream>
#include <iterator>   // for std::ostream_iterator
#include <algorithm>  // for swap
#include <string>
#include <list>
 
#include "lsst/jointcal/Point.h"
#include "lsst/jointcal/BaseStar.h"             // class definition used in inlined functions
#include "lsst/jointcal/AstrometryTransform.h"  // inlined function calls AstrometryTransform::apply()
 
namespace lsst {
namespace jointcal {
 
 
class StarMatch {
    friend class StarMatchList;
 
public:
    /* if one sets that private, then fitting routines will be a nightmare. we could set all the Transform
     * classes friend... */
    FatPoint point1, point2;  
    std::shared_ptr<const BaseStar> s1, s2;
    double distance;
    double chi2;
 
 
    StarMatch(const FatPoint &point1, const FatPoint &point2, std::shared_ptr<const BaseStar> star1,
              std::shared_ptr<const BaseStar> star2)
            : point1(point1), point2(point2), s1(std::move(star1)), s2(std::move(star2)), distance(0.){};
 
    // the next one would require that StarMatch knows BaseStar which is not mandatory for StarMatch to work
    // StarMatch(BaseStar *star1, BaseStar *star2) : point1(*star1), point2(*star2), s1(star1), s2(star2) {};
 
    double computeDistance(const AstrometryTransform &transform) const {
        return point2.Distance(transform.apply(point1));
    };
 
    double computeChi2(const AstrometryTransform &transform) const;
 
    void setDistance(const AstrometryTransform &transform) { distance = computeDistance(transform); };
    double getDistance() const { return distance; }
 
    void swap() {
        std::swap(point1, point2);
        std::swap(s1, s2);
    }
 
    /* comparison that ensures that after a sort, duplicates are next one another */
    explicit StarMatch(){};
 
    friend std::ostream &operator<<(std::ostream &stream, const StarMatch &Match);
 
    ~StarMatch() {}
 
private:
    //  bool operator <  (const StarMatch & other) const { return (s1 > other.s1) ? s1 > other.s1 : s2 >
    //  other.s2;}
 
    /* for unique to remove duplicates */
    bool operator==(const StarMatch &other) const { return (s1 == other.s1 && s2 == other.s2); };
    bool operator!=(const StarMatch &other) const { return (s1 != other.s1 || s2 != other.s2); };
 
    friend bool compareStar1(const StarMatch &one, const StarMatch &two);
    friend bool sameStar1(const StarMatch &one, const StarMatch &two);
    friend bool compareStar2(const StarMatch &one, const StarMatch &two);
    friend bool sameStar2(const StarMatch &one, const StarMatch &two);
};
 
inline bool compareStar1(const StarMatch &one, const StarMatch &two) {
    return ((one.s1 == two.s1) ? (one.distance < two.distance) : (&(*one.s1) > &(*two.s1)));
}
 
inline bool sameStar1(const StarMatch &one, const StarMatch &two) { return (one.s1 == two.s1); }
 
inline bool compareStar2(const StarMatch &one, const StarMatch &two) {
    return ((one.s2 == two.s2) ? (one.distance < two.distance) : (&(*one.s2) > &(*two.s2)));
}
 
inline bool sameStar2(const StarMatch &one, const StarMatch &two) { return (one.s2 == two.s2); }
 
/* =================================== StarMatchList
 * ============================================================ */
 
std::ostream &operator<<(std::ostream &stream, const StarMatch &match);
 
//#ifdef TO_BE_FIXED
typedef ::std::list<StarMatch>::iterator StarMatchIterator;
typedef ::std::list<StarMatch>::const_iterator StarMatchCIterator;
//#endif
 
 
std::ostream &operator<<(std::ostream &stream, const StarMatchList &starMatchList);
 
class StarMatchList : public std::list<StarMatch> {
public:
    void refineTransform(double nSigmas);
 
    void applyTransform(StarMatchList &transformed, const AstrometryTransform *priorTransform,
                        const AstrometryTransform *posteriorTransform = nullptr) const;
 
    /* constructor */
    StarMatchList() : _order(0), _chi2(0){};
 
 
    std::shared_ptr<const AstrometryTransform> getTransform() const { return _transform; }
 
    double getDist2() const { return _dist2; }
 
    double getChi2() const { return _chi2; }
 
    int getTransformOrder() const { return _order; }
 
    void swap();
 
    double computeResidual() const;
 
    unsigned removeAmbiguities(const AstrometryTransform &transform, int which = 3);
 
    void setTransform(const AstrometryTransform *transform) { _transform = transform->clone(); }
    void setTransform(const AstrometryTransform &transform) { _transform = transform.clone(); }
    void setTransform(std::shared_ptr<AstrometryTransform> transform) { _transform = std::move(transform); }
 
    void setTransformOrder(int order);
 
    std::unique_ptr<AstrometryTransform> inverseTransform();
 
    void setDistance(const AstrometryTransform &transform);
 
    void cutTail(int nKeep);
 
    int recoveredNumber(double mindist) const;
 
    void printTransform(std::ostream &stream = std::cout) const;
 
    ~StarMatchList(){/* should delete the transform.... or use counted refs*/};
 
private:
    StarMatchList(const StarMatchList &);  // copies nor properly handled
    void operator=(const StarMatchList &);
 
    int _order;
    double _chi2;
    double _dist2;
    std::shared_ptr<AstrometryTransform> _transform;
};
 
double computeDist2(const StarMatchList &S, const AstrometryTransform &transform);
 
double computeChi2(const StarMatchList &L, const AstrometryTransform &transform);
}  // namespace jointcal
}  // namespace lsst
 
#endif  // LSST_JOINTCAL_STAR_MATCH_H