Convolution Edge Detection in Positive vs. Negative OR Light to Dark vs. Dark to Light Edge Transitions

For vertical edge detection, we usually use the following kernels:
- **Sobel Filter**: gives more weight to the pixels in the central rows, which may make it more robust.
- **Scharr Filter**

Convolution-based Vertical Edge Detection Convolution Filters (Kernels)

Vertical edge detection can be implemented programmatically by applying a two-dimensional cross-correlation operation to an image tensor. First, we construct a $$6 \times 8$$ image tensor `X` where the middle columns are black ($$0$$) and the outer columns are white ($$1$$). Next, we define a $$1 \times 2$$ kernel `K` with values $$[1.0, -1.0]$$. We then perform the cross-correlation operation `corr2d(X, K)` to detect the vertical edges. Finally, applying the same kernel to the transposed image `X.t()` results in an output of zeros, verifying that the kernel only detects vertical edges.

```python
X = torch.ones((6, 8))
X[:, 2:6] = 0

K = torch.tensor([[1.0, -1.0]])

Y = corr2d(X, K)

# Apply the kernel to the transposed image (horizontal edges)
corr2d(X.t(), K)
```

Vertical Edge Detection Code Implementation

To illustrate vertical edge detection, consider a $$6 \times 8$$ pixel image where the middle columns are black ($$0$$) and the outer columns are white ($$1$$). Applying a $$1 \times 2$$ kernel of $$[1, -1]$$ via cross-correlation outputs $$0$$ when horizontally adjacent pixels are the same. At the boundaries, it detects the pixel change, outputting $$1$$ for a white-to-black edge and $$-1$$ for a black-to-white edge. If this same kernel is applied to the transposed image—where the edges are now horizontal—the output vanishes, confirming that this specific kernel exclusively detects vertical edges.

University of Michigan - Ann Arbor

Claude

A convolution kernel can act as a finite difference operator to locate pixel changes for edge detection. For example, a $$1 \times 2$$ kernel like $$[1, -1]$$ computes the difference between horizontally adjacent pixels, $$x_{i,j} - x_{(i+1),j}$$. This cross-correlation operation serves as a discrete approximation of the first derivative in the horizontal direction. Mathematically, for an image function $$f(i,j)$$, its derivative is $$-\partial_i f(i,j) = \lim_{\epsilon \to 0} \frac{f(i,j) - f(i+\epsilon,j)}{\epsilon}$$. By applying this kernel, the output is zero where adjacent pixels are identical and non-zero at boundaries, effectively detecting edges.

Convolution Kernel as a Finite Difference Operator

Edge detection is a fundamental image processing application of convolutional layers. It involves locating the boundaries of an object within an image by finding the precise locations of pixel changes. By performing a cross-correlation or convolution operation with a specifically constructed filter matrix, or kernel, the layer can successfully detect distinct kinds of boundaries, such as vertical or horizontal edges.

Object Edge Detection Using Convolution

Dive into Deep Learning

Example of Vertical Edge Detection Using Convolution

If there is a lot of noise in an image, it is hard to detect the edges of an object directly. As a solution, we first preprocess using Gaussian filters to blur the image. After the Gaussian blurring, the edge detection will be more effective.

Preprocessing Before Boundary (Edge) Detection Using Convolution Operation

We can apply different filters to detect edges in different directions.

Visualization of Boundary (Edge) Detection Using Convolution Operation

For detecting edges in some complicated images, it is proposed to use back-propagation when training the Deep learning model to find the optimal weights for the filter (kernel), rather than handpicking the weights. The objective is to find. the optimal values for these weights as parameters so that it appropriately detects the edges.
It may even learn to detect edges that are at 45 degrees or 73 degrees.

Setting Convolution-based Edge Detection Filter (Kernel) Weights Using Backpropagation

Max-pooling can provide translation invariance to features extracted by convolutional layers. For instance, in edge detection, passing the output of a convolutional layer through a $$2	imes 2$$ max-pooling layer ensures that the detected edge pattern will still be recognized even if the input shifts by one element in height or width. As long as the high activation value remains within the pooling window, the pooling layer will consistently output the same maximum value.

Learn Before

Related

Learn After