LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
How to use algorithms to manipulate Images

All of these algorithms require the inclusion of lsst/afw/image/ImageAlgorithm.h, and are in namespace lsst::afw::image.

Apply a functor to each pixel in an Image

afw supports for_each_pixel as a way to process each pixel in an Image, in a similar way to the STL's for_each. The name doesn't follow the LSST C++ guidelines, but in this case I felt that conformity to the spirit of the STL was more important. There are variants of for_each_pixel corresponding to setting a pixel to a function, setting it to a function of an Image, and setting it to a function of its value and a second Image's pixel value. The selection of which of these operations is desired is done by requiring the functor to inherit from a class such as pixelOp0 or pixelOp1XY, each of which is a std::function with a virtual operator() added.

for_each_pixel(Image<LhsT> &lhs, pixelOp0<LhsT> const& func)

Set each pixel in lhs to the value of func.

for_each_pixel(Image<LhsT> &lhs, pixelOp1<LhsT> const& func)

Set each pixel in lhs to the value of func(lhs).

for_each_pixel(Image<LhsT> &lhs, pixelOp1XY<LhsT> const& func)

Set each pixel in lhs to the value of func(x, y, lhs).

for_each_pixel(Image<LhsT> &lhs, Image<RhsT> const& rhs, pixelOp1<RhsT> const& func)

Set each pixel in lhs to the value of func(lhs).

for_each_pixel(Image<LhsT> &lhs, Image<RhsT> const& rhs, pixelOp2<Lhs, RhsT> const& func)

Set each pixel in lhs to the value of func(lhs, rhs).

for_each_pixel(Image<LhsT> &lhs, Image<RhsT> const& rhs, pixelOp2XY<Lhs, RhsT> const& func)

Set each pixel in lhs to the value of func(x, y, lhs, rhs).

Example of using for_each_pixel

This code is in forEachPixel.cc.

afw::table::Key< afw::table::Array< ImagePixelT > > image
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.

Include needed header file, and define a namespace alias

template <typename T>
struct erase : public afwImage::pixelOp0<T> {
T operator()() const override { return 0; }
};
def erase(frame=None)
Definition: ds9.py:96
A functor class equivalent to std::function<ValT ()>, but with a virtual operator()

Here's the simplest possible functor, simply setting each pixel to 0. Note that operator() is declared const, as we pass these functors by (const) reference. If this surprises you, take a look at Meyers, Effective STL, Item 38.

template <typename T>
struct setVal
: public afwImage::pixelOp0<T> { // don't call it fill as people like to say using namespace std
setVal(T val) : _val(val) {}
T operator()() const override { return _val; }
private:
T _val;
};
ImageT val
Definition: CR.cc:146

This one's a bit more interesting. We save a value in the constructor, and use it to set each pixel. It's analogous to std::fill, but if I called it fill then following a using namespace std; the compiler would complain about ambiguity; it's simpler just to use a different name.

template <typename T>
struct addOne : public afwImage::pixelOp1<T> {
T operator()(T val) const override { return val + 1; }
};
A functor class equivalent to std::function<ValT (ValT)>, but with a virtual operator()
template <typename T1, typename T2>
struct divide : public afwImage::pixelOp2<T1, T2> {
T1 operator()(T1 lhs, T2 rhs) const override { return lhs / rhs; }
};
A functor class equivalent to std::function<LhsT (LhsT, RhsT)>, but with a virtual operator()

Here are examples of pixelOp1 and pixelOp2.

template <typename T>
struct Gaussian : public afwImage::pixelOp1XY<T> {
Gaussian(float a, float xc, float yc, float alpha) : _a(a), _xc(xc), _yc(yc), _alpha(alpha) {}
T operator()(int x, int y, T val) const override {
float const dx = x - _xc;
float const dy = y - _yc;
return val + _a * ::exp(-(dx * dx + dy * dy) / (2 * _alpha * _alpha));
}
private:
float _a, _xc, _yc, _alpha;
};
double x
int y
Definition: SpanSet.cc:48
table::Key< int > a
A functor class equivalent to std::function<ValT (int, int, ValT)>, but with a virtual operator()

A functor designed to add a Gaussian to an image

using namespace std;
int main() {
afwImage::Image<int> img2(img1.getDimensions());
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:51
STL namespace.

Declare a couple of Images to play with

// set img1 to 0 (actually, the constructor already did this)
lsst::afw::image::for_each_pixel(img1, erase<float>());
// Set img2 to 10
lsst::afw::image::for_each_pixel(img2, setVal<int>(10));
cout << img1(0, 0) << " " << img2(0, 0) << endl;
T endl(T... args)
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()
// Set img1 += 1
lsst::afw::image::for_each_pixel(img1, addOne<float>());
cout << img1(0, 0) << " " << img2(0, 0) << endl;
// Set img1 = img2 + 1
lsst::afw::image::for_each_pixel(img1, img2, addOne<int>());
cout << img1(0, 0) << " " << img2(0, 0) << endl;
// Set img1 = 10, img2 = 3 then img1 /= img2
lsst::afw::image::for_each_pixel(img1, setVal<float>(10));
lsst::afw::image::for_each_pixel(img2, setVal<int>(3));
lsst::afw::image::for_each_pixel(img1, img2, divide<float, int>());
cout << img1(0, 0) << " " << img2(0, 0) << endl;

Apply erase to each pixel in img1, setVal to each pixel in img2, set img1 = img2 + 1, and finally img1 /= img1

// Set img1 = 10 + Gaussian()
float const peak = 1000.0; // peak value
float const xc = 5.0; // center of Gaussian
float const yc = 3.0; //
float const alpha = 1.5; // "sigma" for Gaussian
lsst::afw::image::for_each_pixel(img1, setVal<float>(10));
lsst::afw::image::for_each_pixel(img1, Gaussian<float>(peak, xc, yc, alpha));
cout << img1(0, 0) << " " << img1(xc, yc) << endl;

Add a Gaussian to the image, centered at (xc, yc) and with central intensity 1000.

}