Java Convolution Matrix

This is specifically for Android so you'll see the two android specific import at the top. However, I think it would apply to java in general. Anyway, here's the code (borrowed from: http://xjaphx.wordpress.com/2011/06/22/image-processing-convolution-matrix/). I'm curious to get feedback on this. What can be faster or more efficient?

import android.graphics.Bitmap;
import android.graphics.Color;

public class ConvolutionMatrix {
    public static final int SIZE = 3;

    public double[][] Matrix;
    public double Factor = 1;
    public double Offset = 1;

    public ConvolutionMatrix() {
        Matrix = new double[SIZE][SIZE];
    }

    public void setAll(double value) {
        for (int x = 0; x < SIZE; x++) {
            for (int y = 0; y < SIZE; y++) {
                Matrix[x][y] = value;
            }
        }
    }

    public void applyConfig(double[][] config) {
        Matrix = config;
    }

    public Bitmap computeConvolution3x3(Bitmap src) {
        int width = src.getWidth();
        int height = src.getHeight();
        Bitmap result = Bitmap.createBitmap(width, height, src.getConfig());

        int A, R, G, B;
        int sumR, sumG, sumB;
        int[][] pixels = new int[SIZE][SIZE];

        for (int y = 0; y < height - 2; ++y) {
            for (int x = 0; x < width - 2; ++x) {
                // get pixel matrix
                for (int i = 0; i < SIZE; ++i) {
                    for (int j = 0; j < SIZE; ++j) {
                        pixels[i][j] = src.getPixel(x + i, y + j);
                    }
                }

                // get alpha of center pixel
                A = Color.alpha(pixels[1][1]);

                // init color sums
                sumR = sumG = sumB = 0;

                // get sum of RGB matrix
                for (int i = 0; i < SIZE; ++i) {
                    for (int j = 0; j < SIZE; ++j) {
                        sumR += (Color.red(pixels[i][j]) * Matrix[i][j]);
                        sumG += (Color.green(pixels[i][j]) * Matrix[i][j]);
                        sumB += (Color.blue(pixels[i][j]) * Matrix[i][j]);
                    }
                }

                // get final red
                R = (int)(sumR/Factor + Offset);
                if (R < 0) R = 0;
                else if (R > 255) R = 255;

                // get final green
                G = (int)(sumG/Factor + Offset);
                if (G < 0) G = 0;
                else if (G > 255) G = 255;

                // get final blue
                B = (int)(sumB/Factor + Offset);
                if (B < 0) B = 0;
                else if (B > 255) B = 255;

                result.setPixel(x+1, y+1, Color.argb(A, R, G, B));
            }
        }

        return result;
    }
}