CONVOL

The CONVOL function convolves an array with a kernel, and returns the result. Convolution is a general process that can be used for various types of smoothing, signal processing, shifting, differentiation, edge detection, etc. The CENTER keyword controls the alignment of the kernel with the array and the ordering of the kernel elements. If CENTER is explicitly set to 0, convolution is performed in the strict mathematical sense; otherwise, the kernel is centered over each data point.

Example

This example uses a kernel to detect diagonal lines in an image.

; Sample image

array = FIX(READ_PNG(FILEPATH('mineral.png', $

  SUBDIRECTORY=['examples','data'])))

; Edge detection kernel

kernel = [ [0,1,0],[-1,0,1],[0,-1,0] ]

result = CONVOL(array, kernel)

im1 = IMAGE(array, LAYOUT=[2,1,1], RGB_TABLE=39)

im2 = IMAGE(result, LAYOUT=[2,1,2], /CURRENT)

Additional Examples

See Additional Examples for more code examples using the CONVOL function.

Using CONVOL

Assume R = CONVOL(A, K, S), where A is an n-element vector, K is an k-element vector (k≤n), and S is the scale factor. If the CENTER keyword is omitted or set to 1:

where the value k/2 is determined by integer division. This means that the result of the division is the largest integer value less than or equal to the fractional number.

If CENTER is explicitly set to 0:

In the two-dimensional, zero CENTER case where A is an m-by-n-element array, and K is the k-by-k element kernel; the result R is an m by n-element array:

The centered case is similar, except the t-i and u-j subscripts are replaced by t+i-k/2 and u+j-k/2.

Syntax

Result = CONVOL( Array, Kernel [, Scale_Factor], BIAS=value, /CENTER, EDGE_CONSTANT=value, /EDGE_MIRROR, /EDGE_REFLECT, /EDGE_TRUNCATE, /EDGE_WRAP, /EDGE_ZERO, INVALID=value, MISSING=value, /NAN, /NORMALIZE )

Return Value

Returns the result of the array convolution. Depending on Array’s type, the computation might be performed using a different type, although the result will always have the same type as Array. The following table shows the types used, as well as any clipping of the result values. The calculation type is also used for Kernel, Scale_Factor, and BIAS.

Array Type	Kernal and Calculation Type	Clipping
BYTE	LONG	[0,255]
INT	LONG	[-32768,32767]
LONG	LONG	None
FLOAT	FLOAT	None
DOUBLE	DOUBLE	None
COMPLEX	COMPLEX	None
DCOMPLEX	DCOMPLEX	None
UINT	LONG	[0,65535]
ULONG	LONG	None
LONG64	LONG64	None
ULONG64	LONG64	None

Arguments

Array

An array of any basic type except string. The result of CONVOL has the same type and dimensions as Array.

Kernel

An array of any type except string. If the type of Kernel is not the same as Array, a copy of Kernel is made and converted to the appropriate type before use (for byte data, the kernel is converted to type LONG). The size of the kernel dimensions must be less than or equal to those of Array. CONVOL accepts non-square kernels including one-dimensional kernels.

Note: According to the mathematical definition of convolution, the kernel should be reversed before performing the computation. Since IDL does not reverse the kernel, it is actually computing the correlation rather than the convolution. For symmetric kernels this distinction is irrelevant. For asymmetric kernels, use REVERSE to change the order of the kernel argument to produce the convolution.

Scale_Factor

A scale factor that is divided into each resulting value. This argument should be of the same type as the input calculation, and will be automatically converted if necessary. For byte or integer input arrays, the argument allows the use of fractional kernel values and avoids overflow of the result. If omitted or set to zero, a scale factor of 1 is used.

Note: The same Scale_Factor is always divided into each result value, regardless of any missing data as specified by the INVALID or NAN keywords. It is usually not appropriate to divide the result value by the full scale factor if portions of the kernel were not applied due to missing data. In this case, you might want to use the NORMALIZE keyword instead.

Keywords

BIAS

Set this keyword to the bias offset to be added to each result value, after any Scale_Factor has been applied. BIAS should be of the same type as the calculation type, and will be automatically converted if necessary. If you have negative kernel values and a byte or unsigned integer input array, you can use this keyword to ensure that the result values are within the range of your data type.

Note: The same BIAS is always added to each result value, regardless of any missing data as specified by the INVALID or NAN keywords. It is usually not appropriate to add the full BIAS if portions of the kernel were not applied due to missing data. In this case, you might want to use the NORMALIZE keyword instead.

CENTER

Set or omit this keyword to center the kernel over each array point. If CENTER is explicitly set to zero, the CONVOL function works in the conventional mathematical sense. In many signal and image processing applications, it is useful to center a symmetric kernel over the data, thereby aligning the result with the original array.

Note that for the kernel to be centered, it must be symmetric about the point K(FLOOR(m/2)), where m is the number of elements in the kernel.

EDGE_CONSTANT

Set this keyword to a specific value to make CONVOL compute the values of elements at the edge of Array as if the array were padded by a constant value. For example, if the array values are represented by "abcdefg" then the effective array will be "...CCCC|abcdefg|CCCC...", where C is the EDGE_CONSTANT value.

Note: Unlike the other EDGE_* keywords (which are simple on/off keywords), EDGE_CONSTANT should be of the same type as the calculation type, and will be automatically converted if necessary.

Note: If none of the EDGE_* keywords are set, CONVOL sets the values of Result to zero (or the value of BIAS) where the kernel extends beyond the edge.

EDGE_MIRROR

Set this keyword to make CONVOL compute the values of elements at the edge of Array by “mirroring” the subscripts of Array at the edge. For example, if the array values are represented by "abcdefg" then the effective array will be "gfedcba|abcdefg|gfedcba".