Some of the kernels (a mask plus particular values) for calculating gradients are Sobel:

[ 1 2 1]

Gy = [ 0 0 0]

[-1 -2 -1]

[ 1 0 -1]

Gx = [ 2 0 -2]

[ 1 0 -1]

or Sharr:

[ 3 10 3]

Gy = [ 0 0 0]

[-3 -10 -3]

[ 3 0 -3]

Gx = [ 10 0 -10]

[ 3 0 -3]

or the simpler stencil we used in the previous posts, which only used neighbouring pixels in one direction to estimate the gradient. What if we want to design our own masks? A useful tool is the multidimensional Taylor series:

In two dimensions we have:

which includes up to third order terms. We can't actually include the two pure third order terms because we only have three points in either the x or y direction, and we need a minimum of four. We can include the mixed third order terms though, so that gives us 8 constraints on our coefficients. Instead of including all 9 points in the stencil we have to drop one, so in the Maxima code below you'll notice that the central point is commented out.

Lets examine the truncation error for the two masks above. First we define a vector of delta x and delta y corresponding to each point in the stencil:

/* define the points in the stencil or mask: */

steps : matrix( /* dx, dy */

[-1, 1],

[0, 1],

[1, 1],

[-1, 0],

/* [0,0], */

[1, 0],

[-1, -1],

[0,-1],

[1, -1] );

Then vectors describing the coefficients in the two masks (we'll just use the y-component for this example):

/* coefficients in sobel mask */

sobel_y : matrix(

[1],

[2],

[1],

[0],

/*[0],*/

[0],

[-1],

[-2],

[-1]

);

/* coefficients in sharr mask */

sharr_y : matrix(

[3],

[10],

[3],

[0],

/*[0],*/

[0],

[-3],

[-10],

[-3]

);

To evaluate the truncation error we also need to create an operator that is based on the multidimensional Taylor series shown above. This will let us simply multiply those vectors by the operator to see what the masks are actually estimating. Here's the operator:

n : matrix_size( steps );

A : zeromatrix(n[1],n[1]);

for j : 1 thru n[1] do ( A[1,j] : 1 );/* f */

for j : 1 thru n[1] do ( A[2,j] : steps[j,1] );/* df/dx */

for j : 1 thru n[1] do ( A[3,j] : steps[j,2] );/* df/dy */

for j : 1 thru n[1] do ( A[4,j] : steps[j,1]^2/2! );/* d2f/dx2 */

for j : 1 thru n[1] do ( A[5,j] : steps[j,2]^2/2! );/* d2f/dy2 */

for j : 1 thru n[1] do ( A[6,j] : 2*steps[j,1]*steps[j,2]/2! );/* d2f/dxdy */

for j : 1 thru n[1] do ( A[7,j] : 3*steps[j,1]*steps[j,2]^2/3! );/* d3f/dxdy2 */

for j : 1 thru n[1] do ( A[8,j] : 3*steps[j,1]^2*steps[j,2]/3! );/* d3f/dx2dy */

Now the truncation error terms are shown by a couple of matrix vector multiplies:

sobel_te : A.sobel_y;

sharr_te : A.sharr_y;

Rather than just getting a single non-zero entry in the third place of the resulting vector we get a non-zero entry in the last place as well. Looking back at our operator, this is the row for the third order mixed derivative term, (d^3 f)/(dx^2 dy). In other words both the Sobel and Sharr operators introduce an error in their estimation of the gradient that is proportional to this mixed derivative.

How to avoid this error? Well, we can choose a right hand side vector that only has a 1 in the third position and zeros everywhere else, and then invert our operator to solve for what the values in our mask should be.

/* define which derivative we want to estimate, constrain the unwanted

ones to be zero: */

derivs : matrix(

[0], /* f */

[0], /* df/dx */

[1], /* df/dy */

[0], /* d2f/dx2 */

[0], /* d2f/dy2 */

[0], /* d2f/dxdy */

[0], /* d3f/dx2dy */

[0] /* d3f/dxdy2 */

);

inv_A : invert(A);

coeffs : inv_A.derivs;

This gives a result with only non-zero coefficients for the points at [0,1] and [0,-1], in other words, the simple estimate we've already been using! There's really no need to include all those other points for the gradient calculation.

## No comments:

## Post a Comment