Gallery: Smooth

The syntax for the aconvovle kernelspec parameter has four parts. The lib indicates that the smoothing kernel is to be constructed from one of the built in library functions. The gaus indicates the function to use: a Gaussian. The values in parentheses are the parameters for the Gaussian. It is a 2D Gaussian. The kernel should extend out to 5 sigma in each direction. The normalization is 1 (arbitrary here as the default is to recompute a normalization so that the volume under the kernel is 1). The final two parameter are the Gaussian sigma terms for the X and Y axes. This example does not include the optional fourth part of the kernelspec -- the location of the center of the smoothing kernel.

Based on this description, we see that this specifies that the data be smoothed by a 2D Gaussian with sigma=3.0 in both X and Y (ie, circularly symmetric) out to a radius of 5*sigma

In this example, we take the image created in the Arbitrary Binning example where the X-axis is the region ID number and the Y-axis is the Energy. That image is smoothed with a 2D rectangular box that is only 1 pixel wide (X-axis) but 10 pixels long (Y-axis).

In this example a version of the Laplace edge detection kernel is used by specifying a set of kernel values using the text, txt token. The values are given in nested parentheses, going from left-to-right, the values represent the bottom left pixel (first value), bottom middle pixel (2nd value), through the upper right pixel (9th value).

Unlike the previous examples we also have set the normalization parameter norm=none. This is because the sum of the pixels in the kernel is 0; so leaving the normalization at its default value would results in pixel values set to NaN.

In this example we use the arfcorr tool to create a quick, low fidelity, estimate of the Chandra PSF. The resulting image is saved in the file 15403.psf. This PSF is shown in the center frame.

We then use that image with aconvolve as the convolution kernel. The input image (shown on the left) is convolved with the PSF (center) to produce the output on the right.

Note: the input image and the PSF do not need to be the same size (MxN number of pixels); the PSF image can be smaller than the input image. However, the images must have the same resolution (pixel size) and tangent point.

The first step is to create the input data cube. Here an HRC event file is filtered on the chip coordinates and then binned into a cube. The X and Y axes are the chipx and chipy values binned by 2, and the third axis is time binned into 50 bins.

This cube is input into aconvolve. The convolution kernel used here acts like a delta function in the X and Y directions, and has an exponential decay along the Z (3rd/time) axis. The Lissajous pattern can be seen as the source dithers across the detector.

csmooth is fairly simple to run. It outputs the smoothed image as well as images that record the smoothing scale and the significance at each pixel location.

Users should be careful about how they use the output image. The flux in the image is not preserved (a local background has been subtracted.) There may also be some unphysical structure that emerges if there is significant structure in the background.

This dmimgadapt output is a direct comparison to the csmooth example above. Both use a Gaussian convolution kernel to get approximately 5-sigma, ie 25 counts.

It's worth highlighting that the dmimgadapt tool knows about the filters which have been applied to the input file (aka the file's data-subspace). This is why the off-chip pixels appear white in this image -- they are actually NaN, whereas csmooth does not know about off-chip pixels, so the same area is filled with the value 0 (shown as black).

This example shows dmimgadapt using the circular cone shaped kernel. This example uses more smoothing kernels than the previous example; and yet because the cone is easier to compute and has a finite base, the dmimgadapt program runs much faster.

Visually this image is nearly identical to the previous example. Since selecting the set of smoothing kernel scales is often an iterative task, we can use the cone kernel to quickly optimize those parameters first and then run again using gaus to produce the final product.

The image shown is the min_100cts.map file. Note that units of the radii are in logical pixels, so if an image is binned > 1, which is the case here, you want to be sure to take that into account when using this file.

See also the Find regions with minimum number of counts thread.

In this example we start by smoothing the image with a 10 pixel Gaussian, and then estimating the gradient using the Laplace convolution kernel. The result here shows a cavity North of the center of the cluster which can then be further analyzed.

The choice of the smoothing scale affects the size of detectable features. To look for large scale features, a large smoothing scale is required. The scale should always be larger than the local PSF size. Since the Chandra PSF varies, some researchers have found innovative ways to combine GGM from several scales into a single product.

In this example we used aconvolve to compute the directional gradient in the X-direction and separately in the Y-direction. Then dmimgcalc is used to compute the magnitude (left) and angle (right) of the gradient. The data are the same shown in the Gaussian Gradient Magnitude example , but zoomed out by 50%. The edge of the cluster emission is easy to identify in the gradient magnitude image (left). The gradient direction image (right) is harder to interpret since the angle wraps at 180 degrees, creating an artificial discontinuity.

Some other common gradient estimators include:

The choice of how large to make g compared to h is discussed in the literature. One common convention is to use a factor 10, so if g is a Gaussian with a 3 pixel sigma, then h should be a Gaussian with a 30 pixel sigma. Other researchers have used various other values (5 and 20).

Finally, we can rearrange the terms above to get

We can then identify the term (g-h) as the difference of Gaussians (DoG). There has been research in this specific topic as the DoG can be used to approximate the Haar (aka Mexican Hat) wavelet. Given this relationship, some users will select scales at 2ⁿ radii.

In this example the power spectrum has been centered such that the middle of the image represents the lowest spatial frequencies (ie the "flat" background) and the highest frequencies are at the edge of the image.

What we see here is an annulus with little power at high frequencies due to the 3 pixel Gaussian filter and littler power at low frequencies due to the subtraction of the 30 pixel Gaussian smoothed image. This annulus is the frequency band-pass represented in the unsharp mask filtered image.

In this example we used the simulate_psf script to run MARX to simulate the PSF at the location of ArLac (center image). We then used the get_sky_limits script to get the limits used to bin the PSF image and use that with dmcopy to make the image of the data (left image). Finally, we used arestore to perform the Lucy-Richardson deconvolution technique with 250 iterations for the deconvolved image (right image).

There appears to be excess flux North of the source. While it may be tempting to think that this is some extended source emission, there are several factors to consider such as the energy used in the PSF simulation and the existence of a known PSF artifact, which can be located using the following command

make_psf_asymmetry_region ar_lac.img anomaly.reg x=16277.5 y=16416.1 format=ds9 clob+

and loading the region onto the deconvolved image.