ListMatch.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_LIST_MATCH_H
#define LSST_JOINTCAL_LIST_MATCH_H
 
#include <string>
 
#include "lsst/jointcal/BaseStar.h"
#include "lsst/jointcal/StarMatch.h"
 
namespace lsst {
namespace jointcal {
 
class AstrometryTransform;
class AstrometryTransformLinear;
 
struct MatchConditions {
    int nStarsList1, nStarsList2;
    int maxTrialCount;
    double nSigmas;
    double maxShiftX, maxShiftY;
    double sizeRatio, deltaSizeRatio, minMatchRatio;
    int printLevel;
    int algorithm;
 
    MatchConditions()
            : nStarsList1(70),
              nStarsList2(70),
              maxTrialCount(4),
              nSigmas(3.),
              maxShiftX(50),
              maxShiftY(50),
              sizeRatio(1),
              deltaSizeRatio(0.1 * sizeRatio),
              minMatchRatio(1. / 3.),
              printLevel(0),
              algorithm(2) {}
 
    double minSizeRatio() const { return sizeRatio - deltaSizeRatio; }
    double maxSizeRatio() const { return sizeRatio + deltaSizeRatio; }
};
 
 
std::unique_ptr<StarMatchList> matchSearchRotShift(BaseStarList &list1, BaseStarList &list2,
                                                   const MatchConditions &conditions);
 
 
std::unique_ptr<StarMatchList> matchSearchRotShiftFlip(BaseStarList &list1, BaseStarList &list2,
                                                       const MatchConditions &conditions);
 
 
std::unique_ptr<StarMatchList> listMatchCollect(const BaseStarList &list1, const BaseStarList &list2,
                                                const AstrometryTransform *guess, double maxDist);
 
 
std::unique_ptr<StarMatchList> listMatchCollect(const BaseStarList &list1, const BaseStarList &list2,
                                                double maxDist);
 
 
std::unique_ptr<AstrometryTransformLinear> listMatchupShift(const BaseStarList &list1,
                                                            const BaseStarList &list2,
                                                            const AstrometryTransform &transform,
                                                            double maxShift, double binSize = 0);
 
std::unique_ptr<AstrometryTransform> listMatchCombinatorial(
        const BaseStarList &list1, const BaseStarList &list2,
        const MatchConditions &conditions = MatchConditions());
std::unique_ptr<AstrometryTransform> listMatchRefine(const BaseStarList &list1, const BaseStarList &list2,
                                                     std::unique_ptr<AstrometryTransform> transform,
                                                     int maxOrder = 3);
 
#ifdef DO_WE_NEED_THAT
inline AstrometryTransform *ListMatch(const BaseStarList &list1, const BaseStarList &list2,
                                      const int maxOrder = 3) {
    AstrometryTransform *transform = listMatchCombinatorial(list1, list2);
    transform = listMatchRefine(list1, list2, transform, maxOrder);
    return transform;
}
#endif /*  DO_WE_NEED_THAT */
}  // namespace jointcal
}  // namespace lsst
 
#endif  // LSST_JOINTCAL_LIST_MATCH_H