LSST Applications  21.0.0-147-g0e635eb1+1acddb5be5,22.0.0+052faf71bd,22.0.0+1ea9a8b2b2,22.0.0+6312710a6c,22.0.0+729191ecac,22.0.0+7589c3a021,22.0.0+9f079a9461,22.0.1-1-g7d6de66+b8044ec9de,22.0.1-1-g87000a6+536b1ee016,22.0.1-1-g8e32f31+6312710a6c,22.0.1-10-gd060f87+016f7cdc03,22.0.1-12-g9c3108e+df145f6f68,22.0.1-16-g314fa6d+c825727ab8,22.0.1-19-g93a5c75+d23f2fb6d8,22.0.1-19-gb93eaa13+aab3ef7709,22.0.1-2-g8ef0a89+b8044ec9de,22.0.1-2-g92698f7+9f079a9461,22.0.1-2-ga9b0f51+052faf71bd,22.0.1-2-gac51dbf+052faf71bd,22.0.1-2-gb66926d+6312710a6c,22.0.1-2-gcb770ba+09e3807989,22.0.1-20-g32debb5+b8044ec9de,22.0.1-23-gc2439a9a+fb0756638e,22.0.1-3-g496fd5d+09117f784f,22.0.1-3-g59f966b+1e6ba2c031,22.0.1-3-g849a1b8+f8b568069f,22.0.1-3-gaaec9c0+c5c846a8b1,22.0.1-32-g5ddfab5d3+60ce4897b0,22.0.1-4-g037fbe1+64e601228d,22.0.1-4-g8623105+b8044ec9de,22.0.1-5-g096abc9+d18c45d440,22.0.1-5-g15c806e+57f5c03693,22.0.1-7-gba73697+57f5c03693,master-g6e05de7fdc+c1283a92b8,master-g72cdda8301+729191ecac,w.2021.39
LSST Data Management Base Package
StarMatch.h
Go to the documentation of this file.
1 // -*- LSST-C++ -*-
2 /*
3  * This file is part of jointcal.
4  *
5  * Developed for the LSST Data Management System.
6  * This product includes software developed by the LSST Project
7  * (https://www.lsst.org).
8  * See the COPYRIGHT file at the top-level directory of this distribution
9  * for details of code ownership.
10  *
11  * This program is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation, either version 3 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program. If not, see <https://www.gnu.org/licenses/>.
23  */
24 
25 #ifndef LSST_JOINTCAL_STAR_MATCH_H
26 #define LSST_JOINTCAL_STAR_MATCH_H
27 
28 #include <iostream>
29 #include <iterator> // for std::ostream_iterator
30 #include <algorithm> // for swap
31 #include <string>
32 #include <list>
33 
34 #include "lsst/jointcal/Point.h"
35 #include "lsst/jointcal/BaseStar.h" // class definition used in inlined functions
36 #include "lsst/jointcal/AstrometryTransform.h" // inlined function calls AstrometryTransform::apply()
37 
38 namespace lsst {
39 namespace jointcal {
40 
52 
54 class StarMatch {
55  friend class StarMatchList;
56 
57 public:
58  /* if one sets that private, then fitting routines will be a nightmare. we could set all the Transform
59  * classes friend... */
63  double distance;
64  double chi2;
65 
67 
71  : point1(point1), point2(point2), s1(std::move(star1)), s2(std::move(star2)), distance(0.){};
72 
73  // the next one would require that StarMatch knows BaseStar which is not mandatory for StarMatch to work
74  // StarMatch(BaseStar *star1, BaseStar *star2) : point1(*star1), point2(*star2), s1(star1), s2(star2) {};
75 
78  return point2.Distance(transform.apply(point1));
79  };
80 
82  double computeChi2(const AstrometryTransform &transform) const;
83 
87  double getDistance() const { return distance; }
88 
89  void swap() {
91  std::swap(s1, s2);
92  }
93 
94  /* comparison that ensures that after a sort, duplicates are next one another */
95  explicit StarMatch(){};
96 
97  friend std::ostream &operator<<(std::ostream &stream, const StarMatch &Match);
98 
100 
101 private:
102  // bool operator < (const StarMatch & other) const { return (s1 > other.s1) ? s1 > other.s1 : s2 >
103  // other.s2;}
104 
105  /* for unique to remove duplicates */
106  bool operator==(const StarMatch &other) const { return (s1 == other.s1 && s2 == other.s2); };
107  bool operator!=(const StarMatch &other) const { return (s1 != other.s1 || s2 != other.s2); };
108 
109  friend bool compareStar1(const StarMatch &one, const StarMatch &two);
110  friend bool sameStar1(const StarMatch &one, const StarMatch &two);
111  friend bool compareStar2(const StarMatch &one, const StarMatch &two);
112  friend bool sameStar2(const StarMatch &one, const StarMatch &two);
113 };
114 
115 inline bool compareStar1(const StarMatch &one, const StarMatch &two) {
116  return ((one.s1 == two.s1) ? (one.distance < two.distance) : (&(*one.s1) > &(*two.s1)));
117 }
118 
119 inline bool sameStar1(const StarMatch &one, const StarMatch &two) { return (one.s1 == two.s1); }
120 
121 inline bool compareStar2(const StarMatch &one, const StarMatch &two) {
122  return ((one.s2 == two.s2) ? (one.distance < two.distance) : (&(*one.s2) > &(*two.s2)));
123 }
124 
125 inline bool sameStar2(const StarMatch &one, const StarMatch &two) { return (one.s2 == two.s2); }
126 
127 /* =================================== StarMatchList
128  * ============================================================ */
129 
130 std::ostream &operator<<(std::ostream &stream, const StarMatch &match);
131 
132 //#ifdef TO_BE_FIXED
133 typedef ::std::list<StarMatch>::iterator StarMatchIterator;
134 typedef ::std::list<StarMatch>::const_iterator StarMatchCIterator;
135 //#endif
136 
138 
147 std::ostream &operator<<(std::ostream &stream, const StarMatchList &starMatchList);
148 
149 class StarMatchList : public std::list<StarMatch> {
150 public:
151  void refineTransform(double nSigmas);
152 
155  void applyTransform(StarMatchList &transformed, const AstrometryTransform *priorTransform,
156  const AstrometryTransform *posteriorTransform = nullptr) const;
157 
158  /* constructor */
159  StarMatchList() : _order(0), _chi2(0){};
160 
162 
165 
167  double getDist2() const { return _dist2; }
168 
170  double getChi2() const { return _chi2; }
171 
173  int getTransformOrder() const { return _order; }
174 
176  void swap();
177 
179  double computeResidual() const;
180 
184  unsigned removeAmbiguities(const AstrometryTransform &transform, int which = 3);
185 
187  void setTransform(const AstrometryTransform *transform) { _transform = transform->clone(); }
189  void setTransform(const AstrometryTransform &transform) { _transform = transform.clone(); }
191 
193  void setTransformOrder(int order);
194 
198 
201 
203  void cutTail(int nKeep);
204 
206  int recoveredNumber(double mindist) const;
207 
209  void printTransform(std::ostream &stream = std::cout) const;
210 
211  ~StarMatchList(){/* should delete the transform.... or use counted refs*/};
212 
213 private:
214  StarMatchList(const StarMatchList &); // copies nor properly handled
215  void operator=(const StarMatchList &);
216 
217  int _order;
218  double _chi2;
219  double _dist2;
221 };
222 
224 double computeDist2(const StarMatchList &S, const AstrometryTransform &transform);
225 
227 double computeChi2(const StarMatchList &L, const AstrometryTransform &transform);
228 } // namespace jointcal
229 } // namespace lsst
230 
231 #endif // LSST_JOINTCAL_STAR_MATCH_H
table::Key< int > transform
a virtual (interface) class for geometric transformations.
A Point with uncertainties.
Definition: FatPoint.h:34
double Distance(const Point &other) const
Definition: Point.h:51
A hanger for star associations.
Definition: StarMatch.h:54
double computeChi2(const AstrometryTransform &transform) const
returns the chi2 (using errors in the FatPoint's)
Definition: StarMatch.cc:44
std::shared_ptr< const BaseStar > s1
Definition: StarMatch.h:62
std::shared_ptr< const BaseStar > s2
Definition: StarMatch.h:62
void setDistance(const AstrometryTransform &transform)
to be used before sorting on distances.
Definition: StarMatch.h:85
friend bool sameStar2(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:125
StarMatch(const FatPoint &point1, const FatPoint &point2, std::shared_ptr< const BaseStar > star1, std::shared_ptr< const BaseStar > star2)
constructor.
Definition: StarMatch.h:69
double computeDistance(const AstrometryTransform &transform) const
returns the distance from transform(point1) to point2.
Definition: StarMatch.h:77
double getDistance() const
returns the value computed by the above one.
Definition: StarMatch.h:87
friend bool compareStar2(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:121
FatPoint point2
2 points
Definition: StarMatch.h:60
friend std::ostream & operator<<(std::ostream &stream, const StarMatch &Match)
Definition: StarMatch.cc:56
friend bool sameStar1(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:119
friend bool compareStar1(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:115
std::unique_ptr< AstrometryTransform > inverseTransform()
returns the inverse transform (swap, fit(refineTransform) , and swap).
Definition: StarMatch.cc:174
void setDistance(const AstrometryTransform &transform)
Sets the distance (residual) field of all std::list elements. Mandatory before sorting on distances.
Definition: StarMatch.cc:141
void setTransform(const AstrometryTransform &transform)
Definition: StarMatch.h:189
void printTransform(std::ostream &stream=std::cout) const
print the matching transformation quality (transform, chi2, residual)
Definition: StarMatch.cc:230
void swap()
swaps elements 1 and 2 of each starmatch in std::list.
Definition: StarMatch.cc:199
double getChi2() const
access to the chi2 of the last call to refineTransform.
Definition: StarMatch.h:170
void setTransform(std::shared_ptr< AstrometryTransform > transform)
Definition: StarMatch.h:190
int getTransformOrder() const
returns the order of the used transform
Definition: StarMatch.h:173
void setTransform(const AstrometryTransform *transform)
sets a transform between the 2 std::lists and deletes the previous or default one....
Definition: StarMatch.h:187
int recoveredNumber(double mindist) const
count the number of elements for which distance is < mindist
Definition: StarMatch.cc:205
void setTransformOrder(int order)
set transform according to the given order.
Definition: StarMatch.cc:160
double computeResidual() const
returns the average 1d Residual (last call to refineTransform)
Definition: StarMatch.cc:136
unsigned removeAmbiguities(const AstrometryTransform &transform, int which=3)
cleans up the std::list of pairs for pairs that share one of their stars, keeping the closest one.
Definition: StarMatch.cc:145
double getDist2() const
access to the sum of squared residuals of the last call to refineTransform.
Definition: StarMatch.h:167
void cutTail(int nKeep)
deletes the tail of the match std::list
Definition: StarMatch.cc:191
void applyTransform(StarMatchList &transformed, const AstrometryTransform *priorTransform, const AstrometryTransform *posteriorTransform=nullptr) const
enables to get a transformed StarMatchList.
Definition: StarMatch.cc:214
void refineTransform(double nSigmas)
removes pairs beyond nSigmas in distance (where the sigma scale is set by the fit) and iterates until...
Definition: StarMatch.cc:94
std::shared_ptr< const AstrometryTransform > getTransform() const
carries out a fit with outlier rejection
Definition: StarMatch.h:164
T move(T... args)
bool operator==(FilterProperty const &rhs) const noexcept
Return true iff two FilterProperties are identical.
bool operator!=(FilterProperty const &rhs) const noexcept
Return true iff rhs != this.
Definition: Filter.h:100
bool compareStar1(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:115
bool sameStar2(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:125
bool sameStar1(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:119
bool compareStar2(const StarMatch &one, const StarMatch &two)
Definition: StarMatch.h:121
double computeDist2(const StarMatchList &S, const AstrometryTransform &transform)
sum of distance squared
Definition: StarMatch.cc:239
::std::list< StarMatch >::const_iterator StarMatchCIterator
Definition: StarMatch.h:134
std::ostream & operator<<(std::ostream &stream, AstrometryMapping const &mapping)
::std::list< StarMatch >::iterator StarMatchIterator
Definition: StarMatch.h:133
double computeChi2(const StarMatchList &L, const AstrometryTransform &transform)
the actual chi2
Definition: StarMatch.cc:246
A base class for image defects.
STL namespace.
T swap(T... args)
table::Key< int > order