You describe how to determine if a filter is separable in the time domain. What if I have an filter in the frequency domain only, and want to recognize if it is separable, and possibly write the h1 and h2 components of the filter in the time domain, whithout using ifft2?

Concerning the built-in n-D convolution methods:

MATLAB (v2008b) keeps failing due to out-of-memory errors when convolving large 3D arrays (e.g. (256)^3) with a ~16^3 (general, non-separable) kernel.

I’ve tried imfilter, convn or convnfft from the filexchange, same result …

Would it make sense to add an functionality that transparently breaks down the task into filtering smaller sub-arrays and stitches together the results, depending on the free contiguous memory blocks, to prevent memory errors? Or can you think of another solution ?

Thanks

Vasek

For instance I have a 3D mask and intend to convolve with a guassian. I know that the gaussian is separable, how do I go about separating the kernel for convolution in 3D ?

regards

GT

I am just entering the image processing realm and have what is probably a very basic question.

Let G_MxM be a separable filter given by

Gx_MxM = d_Mx1 * s_1xM,

where “*” denotes matrix multiplication.

The result of filtering [1] an input matrix X at row n and column m by
this Gx matrix is then

Yx_M(n,m) = X_M(n,m) * Gx
= X_M(n,m) * d * s
= (X_M(n,m) * d) * s,

where X_M(n,m) and Yx_M(n,x) are the MxM matrices at n, m.

Further expanding this gives

Yx(n,m) = s(m) * \sum_{k = 0}{M – 1} X(n, m + k) d(k),

where X(n,m) and Yx(n,m) are the elements of the matrices X and Yx at row
n and column m, respectively.

Now note that the product of X_M and d is a 1D convolution of the filter
d along the nth row of X_M, and the value s(m) simply scales that
convolution.

Thus if d is the simple 1D difference filter [1 0 -1] (as it is for a
Sobel filter), then this operation produces the derivative of X_M along
the nth row of X_M, or what I would call the gradient in the x
direction.

Fine. Great.

But then, if Gy = Gx’, as it is here for a Sobel filter,

http://en.wikipedia.org/wiki/Sobel_operator

then the gradient in the y direction is

Yy_M(n,m) = X_M(n,m) * Gy

and therefore

Yy(n,m) = d(m) * \sum_{k = 0}{M – 1} X(n, m+k) s(k).

By the same mathematics as above, we see that the product
of X_M and s is a 1D convolution of the filter s along
the nth row of X_M.

But this is NOT the gradient of X in the y direction, since such a
gradient would have to be performed on the COLUMNS of X.

So from this reasoning, it seems that to determine the x-gradient
of X we should compute

X * Gx

but to determine the y-gradient of X we should compute

Gy * X.

Is this correct? If so, then isn’t is also true that to perform these
gradients correctly one must have a side-specific image filter
operation? Specifically, my question is, if this is true, how can the
Matlab/Octave image processing library’s imfilter(X,Gx) and
imfilter(X,Gy) compute both gradients correctly, since it presumably
multiplies on only one “side” and thus one would be incorrect?

–Randy

[1] We ignore various details such as edge effects and the sign-reversal
that standard convolution requires here to simplify the notation and
presentation.