Sean Dai

Image Source: Jain, R., Kasturi, R., Schunck, B. Machine Vision.

Image Filtering

Image filtering is governed by the following equation:

where
g(i, j) = the value of the output pixel at image point (i, j)
f(i, j) = the input pixel value at point (i, j)
h(k, l) = the value at coordinate (k, l) of the kernel h.

Method

In order to construct the filtered image, we first center an kxl kernel h, where k and l are odd, with a pixel (i, j) in the input image; then, we obtain the output pixel value at (i, j) by computing the element-wise dot product between the kxl kernel and the (k,l)-sized neighborhood surrounding the image at that point (i,j).

To address the problem of the kernel window extending past the original image boundaries when filtering border pixels, the input image is padded with 0 pixels along the edges so that the kernel window aligns nicely at those edges. One downside of this approach is that the filtered image appears darker around the borders, which may be bothersome when creating the hybrid images.

my_imfilter() Implementation

function output = my_imfilter(image, filter)
output = imy_imfilter(image, filter, 0);
end

% padtype - takes values 0, 'circular', 'replicate', and 'symmetric'
function ioutput = imy_imfilter(image, filter, padtype)
    [rows, cols, dims] = size(image);
    [m, n] = size(filter); % The kernel is assumed to be odd mxn matrix.
    ioutput = zeros([rows cols dims]);

    % Deals with the issue of the kernel window being out of bounds at the edges. 
    % Pads the sides of the image with 0-valued pixels.
    padded_img = padarray(image, floor([m n] ./ 2), padtype); 
    convolve_neighborhood = @(region, kernel) sum(sum(region .* kernel));

    % Filter the image by centering the kernel window at every pixel.
    for d=1:dims
        for r=1:rows
            for c=1:cols
                ioutput(r,c,d) = convolve_neighborhood(...
                padded_img(r:r+m-1, c:c+n-1, d), filter);
            end
        end
    end
end

Results

Identity Image		Original, unfiltered image.
Blur Image		Output image produced by a 3x3 box filter.
Large Blur Image		Output image after blurring with a 25x1 Gaussian filter (σ=10) along horizontal and vertical directions.
High Pass Image		Output image after convolving input with (1-B), where B is the 3x3 box filter.
Sobel Image		Output image displaying prominent vertical edges from the original image.
Laplacian Image		Output image after applying the positive Laplacian operator ([0 1 0; 1 -4 1; 0 1 0]) to the original image.

Hybrid Images

Method

As mentioned in the Hybrid Images paper, the process of creating a hybrid image from two separate images involves

1. Filtering the image to be visible from a distance (I1) with a low pass filter (i.e. Gaussian kernel G1).

low_frequencies = my_imfilter(image1, filter);

2. Filtering the image that is visible from up close (I2) with a high pass filter (i.e. 1-G2, where G2 is Gaussian kernel).

high_frequencies = image2 - my_imfilter(image2, filter);

3. Once these two steps are finished, we simply add the two filtered images together to produce the hybrid image.

   hybrid_image = low_frequencies + high_frequencies;

The parameter cutoff_frequency specifies the standard deviation σ for both Gaussian kernels G1 and G2 and must be tuned to produce the appropriate hybrid image. The code provided in proj1.m uses a single cutoff_frequency for both G1 and G2. However, the Hybrid Images paper recommends selecting a separate cutoff_frequency for each filter that corresponds to the frequency when the amplitude gain of the filter is 1/2.

Results: Image Pairs

Below are the scale representations of the above pairs of hybrid images.