lsst.afw  20.0.0-17-g80088cf60+109ac6652c
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.

Include needed header file, and define a namespace alias

template <typename T>
struct erase : public afwImage::pixelOp0<T> {
T operator()() const { return 0; }
};

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 { return _val; }
private:
T _val;
};

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 { return val + 1; }
};
template <typename T1, typename T2>
struct divide : public afwImage::pixelOp2<T1, T2> {
T1 operator()(T1 lhs, T2 rhs) const { return lhs / rhs; }
};

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 {
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;
};

A functor designed to add a Gaussian to an image

using namespace std;
int main() {
afwImage::Image<int> img2(img1.getDimensions());

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;
// 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.

}
y
int y
Definition: SpanSet.cc:49
lsst::afw::image
Backwards-compatibility support for depersisting the old Calib (FluxMag0/FluxMag0Err) objects.
Definition: imageAlgorithm.dox:1
ImageAlgorithm.h
lsst::afw::image::pixelOp0
A functor class equivalent to std::function<ValT ()>, but with a virtual operator()
Definition: ImageAlgorithm.h:52
image
afw::table::Key< afw::table::Array< ImagePixelT > > image
Definition: HeavyFootprint.cc:216
x
double x
Definition: ChebyshevBoundedField.cc:277
lsst::afw::image::pixelOp1
A functor class equivalent to std::function<ValT (ValT)>, but with a virtual operator()
Definition: ImageAlgorithm.h:61
lsst::afw::image::for_each_pixel
void for_each_pixel(Image< LhsT > &lhs, pixelOp0< LhsT > const &func)
Set each pixel in an Image<LhsT> to func()
Definition: ImageAlgorithm.h:97
std::endl
T endl(T... args)
a
table::Key< int > a
Definition: TransmissionCurve.cc:466
std
STL namespace.
lsst::afw::image::pixelOp2
A functor class equivalent to std::function<LhsT (LhsT, RhsT)>, but with a virtual operator()
Definition: ImageAlgorithm.h:79
lsst::afw::image::pixelOp1XY
A functor class equivalent to std::function<ValT (int, int, ValT)>, but with a virtual operator()
Definition: ImageAlgorithm.h:70
lsst::afw::image::Image
A class to represent a 2-dimensional array of pixels.
Definition: Image.h:58
lsst::afw.display.ds9.erase
def erase(frame=None)
Definition: ds9.py:97
Extent< int, 2 >