VisualApplets
Operator Reference

Operator Library: Filter

The operator FIRkernelNxM creates rectangular kernel window around each pixel, which includes the neighbor pixels. The size of the kernel can be defined by editing the output link. N represents the number of kernel rows and M the number of kernel columns.

Other operators to generate kernels are the operators LineNeighboursNx1 and PixelNeighbours1xM.

The central element of a kernel always represents the original input pixel of the respective position. The output image O with pixel indices x and y and kernel indices m and n is derived from the input by:

with and

At image edges, no neighbored pixels are defined. The operator allows the definition of the required edge handling algorithm using the parameter EdgeHandling.

For kernels of even size, there is no central pixel. In this case, the central pixel is displaced to the upper left corner, e.g. for a kernel of size 4x4 defines the central pixel at (1,1) as can be seen in the following table.

Kernels are described by the number of rows and columns. In VisualApplets, N represents the number of rows, and M represents the number of columns. Often, kernel elements are addressed by their index instead of their coordinate. In this case, the order is row by row as shown in the following table.

The following example shows the resulting composition for three kernel rows and three kernel columns. The 3x3 matrix in the depicted operator provides the relative addressing that defines the content of the respective kernels. Each 3x3 cluster on the output shows the different kernel values per pixel.

Instead of kernel configurations per pixel, this example shows the resulting subkernels: the first kernel at index 0 and the last kernel at index 8.

The following example shows the resulting composition for two kernel rows and two kernel columns. As the relative addresses only reference neighbors on the right hand side or below, no edge handling needs to be performed for content to the left or at top.

Comparing the last two examples with odd and even kernel sizes shows a noticeable behavior of the edgeHandling feature in edgeMirroring mode. While edgeMirroring for even and odd kernel sizes is treated identically on top and left borders, it produces slightly different results on the bottom and the right hand side. Due to the large output image size only the resulting configurations for the first, upper right, and last, lower right, input pixel with their resulting values per kernel are presented:

EdgeMirroring for odd kernel sizes fills regions with missing data from equidistant regions with data. The border is preserved and not replicated. The same principle is valid for filling regions to the top or to the left for even kernel sizes. In contrast to this, filling regions to the bottom or to the right replicates the border during mirroring. Again, this only occurs for even kernel sizes.

Technically, the operator waits and buffers the required pixels of the kernel until they can be output in parallel. Therefore, the operator will cause a delay as pixels can only be output after all required respective neighbor pixels were processed at the input. The line delay is: