LSSTApplications  20.0.0
LSSTDataManagementBasePackage
Separable.cc
Go to the documentation of this file.
1 // -*- lsst-c++ -*-
2 
3 /*
4  * LSST Data Management System
5  * Copyright 2008, 2009, 2010 LSST Corporation.
6  *
7  * This product includes software developed by the
8  * LSST Project (http://www.lsst.org/).
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the LSST License Statement and
21  * the GNU General Public License along with this program. If not,
22  * see <http://www.lsstcorp.org/LegalNotices/>.
23  */
29 
30 namespace lsst {
31 namespace afw {
32 namespace geom {
33 namespace ellipses {
34 
35 template <typename Ellipticity_, typename Radius_>
36 BaseCore::Registrar<Separable<Ellipticity_, Radius_> > Separable<Ellipticity_, Radius_>::registrar;
37 
38 template <typename Ellipticity_, typename Radius_>
40  return "Separable" + Ellipticity_::getName() + Radius_::getName();
41 }
42 
43 template <typename Ellipticity_, typename Radius_>
45  _ellipticity.normalize();
46  _radius.normalize();
47 }
48 
49 template <typename Ellipticity_, typename Radius_>
51  setE1(*iter++);
52  setE2(*iter++);
53  setRadius(*iter++);
54 }
55 
56 template <typename Ellipticity_, typename Radius_>
58  *iter++ = getE1();
59  *iter++ = getE2();
60  *iter++ = getRadius();
61 }
62 
63 template <typename Ellipticity_, typename Radius_>
66  _ellipticity = other._ellipticity;
67  _radius = other._radius;
68  return *this;
69 }
70 
71 // Delegate to copy-constructor for backwards compatibility
72 template <typename Ellipticity_, typename Radius_>
75  return *this = other;
76 }
77 template <typename Ellipticity_, typename Radius_>
78 Separable<Ellipticity_, Radius_>::Separable(double e1, double e2, double radius, bool normalize)
79  : _ellipticity(e1, e2), _radius(radius) {
80  if (normalize) this->normalize();
81 }
82 
83 template <typename Ellipticity_, typename Radius_>
85  bool normalize)
86  : _ellipticity(complex), _radius(radius) {
87  if (normalize) this->normalize();
88 }
89 
90 template <typename Ellipticity_, typename Radius_>
91 Separable<Ellipticity_, Radius_>::Separable(Ellipticity const& ellipticity, double radius, bool normalize)
92  : _ellipticity(ellipticity), _radius(radius) {
93  if (normalize) this->normalize();
94 }
95 
96 template <typename Ellipticity_, typename Radius_>
98  : _ellipticity(vector[0], vector[1]), _radius(vector[2]) {
99  if (normalize) this->normalize();
100 }
101 
102 template <typename Ellipticity_, typename Radius_>
103 void Separable<Ellipticity_, Radius_>::_assignToQuadrupole(double& ixx, double& iyy, double& ixy) const {
104  Distortion distortion(_ellipticity);
105  _radius.assignToQuadrupole(distortion, ixx, iyy, ixy);
106 }
107 
108 template <typename Ellipticity_, typename Radius_>
110  double& ixy) const {
111  Distortion distortion;
112  BaseCore::Jacobian rhs = Jacobian::Identity();
113  rhs.block<2, 2>(0, 0) = distortion.dAssign(_ellipticity);
114  BaseCore::Jacobian lhs = _radius.dAssignToQuadrupole(distortion, ixx, iyy, ixy);
115  return lhs * rhs;
116 }
117 
118 template <typename Ellipticity_, typename Radius_>
119 void Separable<Ellipticity_, Radius_>::_assignToAxes(double& a, double& b, double& theta) const {
120  double ixx, iyy, ixy;
121  this->_assignToQuadrupole(ixx, iyy, ixy);
122  BaseCore::_assignQuadrupoleToAxes(ixx, iyy, ixy, a, b, theta);
123 }
124 
125 template <typename Ellipticity_, typename Radius_>
127  double& theta) const {
128  double ixx, iyy, ixy;
129  BaseCore::Jacobian rhs = this->_dAssignToQuadrupole(ixx, iyy, ixy);
130  BaseCore::Jacobian lhs = BaseCore::_dAssignQuadrupoleToAxes(ixx, iyy, ixy, a, b, theta);
131  return lhs * rhs;
132 }
133 
134 template <typename Ellipticity_, typename Radius_>
135 void Separable<Ellipticity_, Radius_>::_assignFromQuadrupole(double ixx, double iyy, double ixy) {
136  Distortion distortion;
137  _radius.assignFromQuadrupole(ixx, iyy, ixy, distortion);
138  _ellipticity = distortion;
139 }
140 
141 template <typename Ellipticity_, typename Radius_>
143  double ixy) {
144  Distortion distortion;
145  BaseCore::Jacobian rhs = _radius.dAssignFromQuadrupole(ixx, iyy, ixy, distortion);
146  BaseCore::Jacobian lhs = BaseCore::Jacobian::Identity();
147  lhs.block<2, 2>(0, 0) = _ellipticity.dAssign(distortion);
148  return lhs * rhs;
149 }
150 
151 template <typename Ellipticity_, typename Radius_>
152 void Separable<Ellipticity_, Radius_>::_assignFromAxes(double a, double b, double theta) {
153  double ixx, iyy, ixy;
154  BaseCore::_assignAxesToQuadrupole(a, b, theta, ixx, iyy, ixy);
155  this->_assignFromQuadrupole(ixx, iyy, ixy);
156 }
157 
158 template <typename Ellipticity_, typename Radius_>
160  double ixx, iyy, ixy;
161  BaseCore::Jacobian rhs = BaseCore::_dAssignAxesToQuadrupole(a, b, theta, ixx, iyy, ixy);
162  BaseCore::Jacobian lhs = this->_dAssignFromQuadrupole(ixx, iyy, ixy);
163  return lhs * rhs;
164 }
165 
170 
175 
180 } // namespace ellipses
181 } // namespace geom
182 } // namespace afw
183 } // namespace lsst
std::string
STL class.
lsst::afw::geom::ellipses::Separable::_assignFromAxes
void _assignFromAxes(double a, double b, double theta) override
Definition: Separable.cc:152
ellipses
lsst::afw::geom::ellipses::Separable::writeParameters
void writeParameters(double *iter) const override
Definition: Separable.cc:57
Distortion.h
lsst::afw::geom::ellipses::BaseCore::_dAssignAxesToQuadrupole
static Jacobian _dAssignAxesToQuadrupole(double a, double b, double theta, double &ixx, double &iyy, double &ixy)
Return the size of the bounding box for the ellipse core.
Definition: BaseCore.cc:232
lsst::afw
Definition: imageAlgorithm.dox:1
Separable.h
lsst::afw::geom::ellipses::Separable::_assignFromQuadrupole
void _assignFromQuadrupole(double ixx, double iyy, double ixy) override
Definition: Separable.cc:135
lsst::afw::geom::ellipses::Separable::_dAssignFromAxes
Jacobian _dAssignFromAxes(double a, double b, double theta) override
Definition: Separable.cc:159
lsst::afw::geom::ellipses::Distortion::dAssign
Jacobian dAssign(Distortion const &other)
Definition: Distortion.h:70
radii.h
lsst::afw::geom::ellipses::Separable::_assignToAxes
void _assignToAxes(double &a, double &b, double &theta) const override
Definition: Separable.cc:119
ConformalShear.h
lsst::afw::geom::ellipses::Separable::getName
std::string getName() const override
Return a string that identifies this parametrization.
Definition: Separable.cc:39
lsst::afw::geom::ellipses::BaseCore::_dAssignQuadrupoleToAxes
static Jacobian _dAssignQuadrupoleToAxes(double ixx, double iyy, double ixy, double &a, double &b, double &theta)
Return the size of the bounding box for the ellipse core.
Definition: BaseCore.cc:194
lsst::afw::geom::ellipses::Separable
An ellipse core with a complex ellipticity and radius parameterization.
Definition: radii.h:44
other
ItemVariant const * other
Definition: Schema.cc:56
lsst::afw::geom::ellipses::BaseCore::ParameterVector
Eigen::Vector3d ParameterVector
Parameter vector type.
Definition: BaseCore.h:61
lsst::afw::geom::ellipses::Separable::operator=
Separable & operator=(Separable const &other)
Standard assignment.
Definition: Separable.cc:64
lsst::afw::geom::ellipses::Separable::readParameters
void readParameters(double const *iter) override
Definition: Separable.cc:50
b
table::Key< int > b
Definition: TransmissionCurve.cc:467
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
lsst::afw::geom::ellipses::Separable::Ellipticity
Ellipticity_ Ellipticity
Definition: Separable.h:54
lsst::geom
Definition: geomOperators.dox:4
lsst::afw::geom::ellipses::BaseCore::Jacobian
Eigen::Matrix3d Jacobian
Parameter Jacobian matrix type.
Definition: BaseCore.h:64
lsst.pipe.tasks.insertFakes.radius
radius
Definition: insertFakes.py:288
lsst::afw::geom::ellipses::BaseCore::_assignAxesToQuadrupole
static void _assignAxesToQuadrupole(double a, double b, double theta, double &ixx, double &iyy, double &ixy)
Return the size of the bounding box for the ellipse core.
Definition: BaseCore.cc:219
a
table::Key< int > a
Definition: TransmissionCurve.cc:466
lsst::afw::geom::ellipses::Separable::_dAssignFromQuadrupole
Jacobian _dAssignFromQuadrupole(double ixx, double iyy, double ixy) override
Definition: Separable.cc:142
ReducedShear.h
lsst::afw::geom::ellipses::Separable::_assignToQuadrupole
void _assignToQuadrupole(double &ixx, double &iyy, double &ixy) const override
Definition: Separable.cc:103
lsst::afw::geom::ellipses::Separable::Separable
Separable(double e1=0.0, double e2=0.0, double radius=Radius(), bool normalize=true)
Construct from parameter values.
Definition: Separable.cc:78
std::complex< double >
lsst::afw::geom::ellipses::Separable::_dAssignToQuadrupole
Jacobian _dAssignToQuadrupole(double &ixx, double &iyy, double &ixy) const override
Definition: Separable.cc:109
lsst::afw::geom::ellipses::Distortion
A complex ellipticity with magnitude .
Definition: Distortion.h:44
astshim.fitsChanContinued.iter
def iter(self)
Definition: fitsChanContinued.py:88
lsst::afw::geom::ellipses::BaseCore::_assignQuadrupoleToAxes
static void _assignQuadrupoleToAxes(double ixx, double iyy, double ixy, double &a, double &b, double &theta)
Return the size of the bounding box for the ellipse core.
Definition: BaseCore.cc:184
lsst::afw::geom::ellipses::Separable::_dAssignToAxes
Jacobian _dAssignToAxes(double &a, double &b, double &theta) const override
Definition: Separable.cc:126
lsst::afw::geom::ellipses::Separable::normalize
void normalize() override
Put the parameters into a "standard form", and throw InvalidParameterError if they cannot be normaliz...
Definition: Separable.cc:44