LSSTApplications  18.0.0+106,18.0.0+50,19.0.0,19.0.0+1,19.0.0+10,19.0.0+11,19.0.0+13,19.0.0+17,19.0.0+2,19.0.0-1-g20d9b18+6,19.0.0-1-g425ff20,19.0.0-1-g5549ca4,19.0.0-1-g580fafe+6,19.0.0-1-g6fe20d0+1,19.0.0-1-g7011481+9,19.0.0-1-g8c57eb9+6,19.0.0-1-gb5175dc+11,19.0.0-1-gdc0e4a7+9,19.0.0-1-ge272bc4+6,19.0.0-1-ge3aa853,19.0.0-10-g448f008b,19.0.0-12-g6990b2c,19.0.0-2-g0d9f9cd+11,19.0.0-2-g3d9e4fb2+11,19.0.0-2-g5037de4,19.0.0-2-gb96a1c4+3,19.0.0-2-gd955cfd+15,19.0.0-3-g2d13df8,19.0.0-3-g6f3c7dc,19.0.0-4-g725f80e+11,19.0.0-4-ga671dab3b+1,19.0.0-4-gad373c5+3,19.0.0-5-ga2acb9c+2,19.0.0-5-gfe96e6c+2,w.2020.01
LSSTDataManagementBasePackage
ImageAlgorithm.h
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  */
24 
25 /*
26  * Support for functors over Image's pixels
27  */
28 #ifndef LSST_AFW_IMAGE_IMAGE_ALGORITHM_H
29 #define LSST_AFW_IMAGE_IMAGE_ALGORITHM_H
30 
31 #include <list>
32 #include <map>
33 #include <string>
34 #include <utility>
35 #include <functional>
36 
37 #include "boost/mpl/bool.hpp"
38 #include <memory>
39 
40 #include "lsst/afw/image/lsstGil.h"
42 #include "lsst/daf/base.h"
43 #include "lsst/pex/exceptions.h"
44 
45 namespace lsst {
46 namespace afw {
47 namespace image {
51 template <typename ValT>
52 struct pixelOp0 : public std::function<ValT()> {
53  virtual ~pixelOp0() {}
54  virtual ValT operator()() const = 0;
55 };
56 
60 template <typename ValT>
61 struct pixelOp1 : public std::function<ValT(ValT)> {
62  virtual ~pixelOp1() {}
63  virtual ValT operator()(ValT lhs) const = 0;
64 };
65 
69 template <typename ValT>
70 struct pixelOp1XY : public std::function<ValT(int, int, ValT)> {
71  virtual ~pixelOp1XY() {}
72  virtual ValT operator()(int x, int y, ValT lhs) const = 0;
73 };
74 
78 template <typename LhsT, typename RhsT>
79 struct pixelOp2 : public std::function<LhsT(LhsT, RhsT)> {
80  virtual ~pixelOp2() {}
81  virtual LhsT operator()(LhsT lhs, RhsT rhs) const = 0;
82 };
83 
87 template <typename LhsT, typename RhsT>
88 struct pixelOp2XY : public std::function<LhsT(int, int, LhsT, RhsT)> {
89  virtual ~pixelOp2XY() {}
90  virtual LhsT operator()(int x, int y, LhsT lhs, RhsT rhs) const = 0;
91 };
92 
96 template <typename LhsT>
98  pixelOp0<LhsT> const& func
99 ) {
100  for (int y = 0; y != lhs.getHeight(); ++y) {
101  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
102  lhsPtr != lhsEnd; ++lhsPtr) {
103  *lhsPtr = func();
104  }
105  }
106 }
107 
111 template <typename LhsT>
113  pixelOp1<LhsT> const& func
114 ) {
115  for (int y = 0; y != lhs.getHeight(); ++y) {
116  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
117  lhsPtr != lhsEnd; ++lhsPtr) {
118  *lhsPtr = func(*lhsPtr);
119  }
120  }
121 }
122 
128 template <typename LhsT>
130  pixelOp1XY<LhsT> const& func
131 ) {
132  for (int y = 0; y != lhs.getHeight(); ++y) {
133  int x = lhs.getX0();
134  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
135  lhsPtr != lhsEnd; ++lhsPtr, ++x) {
136  *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr);
137  }
138  }
139 }
140 
144 template <typename LhsT, typename RhsT>
146  Image<RhsT> const& rhs,
147  pixelOp1<RhsT> const& func
148 ) {
149  if (lhs.getDimensions() != rhs.getDimensions()) {
151  (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
152  lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
153  .str());
154  }
155 
156  for (int y = 0; y != lhs.getHeight(); ++y) {
157  typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
158 
159  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
160  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
161  *lhsPtr = func(*rhsPtr);
162  }
163  }
164 }
165 
169 template <typename LhsT, typename RhsT>
171  Image<RhsT> const& rhs,
172  pixelOp2<LhsT, RhsT> const& func
173 ) {
174  if (lhs.getDimensions() != rhs.getDimensions()) {
176  (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
177  lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
178  .str());
179  }
180 
181  for (int y = 0; y != lhs.getHeight(); ++y) {
182  typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
183 
184  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
185  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr) {
186  *lhsPtr = func(*lhsPtr, *rhsPtr);
187  }
188  }
189 }
195 template <typename LhsT, typename RhsT>
197  Image<RhsT> const& rhs,
198  pixelOp2XY<LhsT, RhsT> const& func
199 ) {
200  if (lhs.getDimensions() != rhs.getDimensions()) {
202  (boost::format("Images are of different size, %dx%d v %dx%d") % lhs.getWidth() %
203  lhs.getHeight() % rhs.getWidth() % rhs.getHeight())
204  .str());
205  }
206 
207  for (int y = 0; y != lhs.getHeight(); ++y) {
208  typename Image<RhsT>::const_x_iterator rhsPtr = rhs.row_begin(y);
209  int x = lhs.getX0();
210  for (typename Image<LhsT>::x_iterator lhsPtr = lhs.row_begin(y), lhsEnd = lhs.row_end(y);
211  lhsPtr != lhsEnd; ++rhsPtr, ++lhsPtr, ++x) {
212  *lhsPtr = func(x, y + lhs.getY0(), *lhsPtr, *rhsPtr);
213  }
214  }
215 }
216 } // namespace image
217 } // namespace afw
218 } // namespace lsst
219 
220 #endif
def format(config, name=None, writeSourceLine=True, prefix="", verbose=False)
Definition: history.py:174
A functor class equivalent to std::function<LhsT (LhsT, RhsT)>, but with a virtual operator() ...
A functor class equivalent to std::function<ValT (int, int, ValT)>, but with a virtual operator() ...
int getHeight() const
Return the number of rows in the image.
Definition: ImageBase.h:335
Reports attempts to exceed implementation-defined length limits for some classes. ...
Definition: Runtime.h:76
_const_view_t::x_iterator const_x_iterator
A const iterator for traversing the pixels in a row.
Definition: ImageBase.h:141
_view_t::x_iterator x_iterator
An iterator for traversing the pixels in a row.
Definition: ImageBase.h:133
int y
Definition: SpanSet.cc:49
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()
int getX0() const
Return the image&#39;s column-origin.
Definition: ImageBase.h:343
x_iterator row_begin(int y) const
Return an x_iterator to the start of the y&#39;th row.
Definition: ImageBase.h:438
A base class for image defects.
A functor class equivalent to std::function<LhsT (int, int, LhsT, RhsT)>, but with a virtual operator...
A functor class equivalent to std::function<ValT ()>, but with a virtual operator() ...
double x
#define LSST_EXCEPT(type,...)
Create an exception with a given type.
Definition: Exception.h:48
int getY0() const
Return the image&#39;s row-origin.
Definition: ImageBase.h:351
int getWidth() const
Return the number of columns in the image.
Definition: ImageBase.h:333
x_iterator row_end(int y) const
Return an x_iterator to the end of the y&#39;th row.
Definition: ImageBase.h:441
A functor class equivalent to std::function<ValT (ValT)>, but with a virtual operator() ...
lsst::geom::Extent2I getDimensions() const
Return the image&#39;s size; useful for passing to constructors.
Definition: ImageBase.h:393
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects...
virtual ValT operator()() const =0
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:58