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 dumpTransform(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