下面列出了怎么用java.awt.image.Kernel的API类实例代码及写法，或者点击链接到github查看源代码。
private static void enableConvolveOp(RenderQueue rq,
SurfaceData srcData,
ConvolveOp cop)
{
// assert rq.lock.isHeldByCurrentThread();
boolean edgeZero =
cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
Kernel kernel = cop.getKernel();
int kernelWidth = kernel.getWidth();
int kernelHeight = kernel.getHeight();
int kernelSize = kernelWidth * kernelHeight;
int sizeofFloat = 4;
int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
RenderBuffer buf = rq.getBuffer();
rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
buf.putInt(ENABLE_CONVOLVE_OP);
buf.putLong(srcData.getNativeOps());
buf.putInt(edgeZero ? 1 : 0);
buf.putInt(kernelWidth);
buf.putInt(kernelHeight);
buf.put(kernel.getKernelData(null));
}
private static void enableConvolveOp(RenderQueue rq,
SurfaceData srcData,
ConvolveOp cop)
{
// assert rq.lock.isHeldByCurrentThread();
boolean edgeZero =
cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
Kernel kernel = cop.getKernel();
int kernelWidth = kernel.getWidth();
int kernelHeight = kernel.getHeight();
int kernelSize = kernelWidth * kernelHeight;
int sizeofFloat = 4;
int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
RenderBuffer buf = rq.getBuffer();
rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
buf.putInt(ENABLE_CONVOLVE_OP);
buf.putLong(srcData.getNativeOps());
buf.putInt(edgeZero ? 1 : 0);
buf.putInt(kernelWidth);
buf.putInt(kernelHeight);
buf.put(kernel.getKernelData(null));
}
/**
* Convert image to buffered image.
*
* @param img the object of the image to be converted to buffered image.
* @return the converted buffered image.
*/
public static BufferedImage toBufferedImage(Image img) {
if (img instanceof BufferedImage) {
return (BufferedImage) img;
}
float softenFactor = 0.05f;
final Image temp = new ImageIcon(img).getImage();
final BufferedImage bufferedImage = new BufferedImage(
temp.getWidth(null),
temp.getHeight(null),
BufferedImage.TYPE_INT_RGB);
final Graphics g = bufferedImage.createGraphics();
g.setColor(Color.white);
g.fillRect(0, 0, temp.getWidth(null), temp.getHeight(null));
g.drawImage(temp, 0, 0, null);
g.dispose();
final float[] softenArray = {0, softenFactor, 0, softenFactor, 1 - (softenFactor * 4), softenFactor, 0,
softenFactor, 0};
final Kernel kernel = new Kernel(3, 3, softenArray);
final ConvolveOp cOp = new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
return cOp.filter(bufferedImage, null);
}
@Override
public final BufferedImage apply(BufferedImage img) {
float[][] matrix = getMatrix();
float[] data = getKernelData(matrix);
if(normalize)
normalize(data);
scale(data);
if(isZero(data))
return new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_RGB);
Kernel k = new Kernel(matrix[0].length, matrix.length, data);
ConvolveOp op = new ConvolveOp(k, ConvolveOp.EDGE_NO_OP, null);
BufferedImage img2 = new BufferedImage(img.getWidth(), img.getHeight(), BufferedImage.TYPE_INT_RGB);
img2.getGraphics().drawImage(img, 0, 0, null);
return op.filter(img2, null);
}
public static ConvolveOp getBlurFilter(int radius) {
if (radius < 1) {
throw new IllegalArgumentException("Radius must be >= 1");
}
int size = radius * 2 + 1;
float weight = 1.0f / (size * size);
float[] data = new float[size * size];
for (int i = 0; i < data.length; i++) {
data[i] = weight;
}
Kernel kernel = new Kernel(size, size, data);
return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
}
private static void enableConvolveOp(RenderQueue rq,
SurfaceData srcData,
ConvolveOp cop)
{
// assert rq.lock.isHeldByCurrentThread();
boolean edgeZero =
cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
Kernel kernel = cop.getKernel();
int kernelWidth = kernel.getWidth();
int kernelHeight = kernel.getHeight();
int kernelSize = kernelWidth * kernelHeight;
int sizeofFloat = 4;
int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
RenderBuffer buf = rq.getBuffer();
rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
buf.putInt(ENABLE_CONVOLVE_OP);
buf.putLong(srcData.getNativeOps());
buf.putInt(edgeZero ? 1 : 0);
buf.putInt(kernelWidth);
buf.putInt(kernelHeight);
buf.put(kernel.getKernelData(null));
}
private static void enableConvolveOp(RenderQueue rq,
SurfaceData srcData,
ConvolveOp cop)
{
// assert rq.lock.isHeldByCurrentThread();
boolean edgeZero =
cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
Kernel kernel = cop.getKernel();
int kernelWidth = kernel.getWidth();
int kernelHeight = kernel.getHeight();
int kernelSize = kernelWidth * kernelHeight;
int sizeofFloat = 4;
int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
RenderBuffer buf = rq.getBuffer();
rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
buf.putInt(ENABLE_CONVOLVE_OP);
buf.putLong(srcData.getNativeOps());
buf.putInt(edgeZero ? 1 : 0);
buf.putInt(kernelWidth);
buf.putInt(kernelHeight);
buf.put(kernel.getKernelData(null));
}
private static void enableConvolveOp(RenderQueue rq,
SurfaceData srcData,
ConvolveOp cop)
{
// assert rq.lock.isHeldByCurrentThread();
boolean edgeZero =
cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
Kernel kernel = cop.getKernel();
int kernelWidth = kernel.getWidth();
int kernelHeight = kernel.getHeight();
int kernelSize = kernelWidth * kernelHeight;
int sizeofFloat = 4;
int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
RenderBuffer buf = rq.getBuffer();
rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
buf.putInt(ENABLE_CONVOLVE_OP);
buf.putLong(srcData.getNativeOps());
buf.putInt(edgeZero ? 1 : 0);
buf.putInt(kernelWidth);
buf.putInt(kernelHeight);
buf.put(kernel.getKernelData(null));
}
@Override
public BufferedImage filter(BufferedImage src, BufferedImage dst) {
int width = src.getWidth();
int height = src.getHeight();
pt = createProgressTracker(width + height);
if (dst == null) {
dst = createCompatibleDestImage(src, null);
}
int[] inPixels = new int[width * height];
int[] outPixels = new int[width * height];
getRGB(src, 0, 0, width, height, inPixels);
Kernel kernel = GaussianFilter.makeKernel(hRadius);
thresholdBlur(kernel, inPixels, outPixels, width, height, true, pt);
thresholdBlur(kernel, outPixels, inPixels, height, width, true, pt);
setRGB(dst, 0, 0, width, height, inPixels);
finishProgressTracker();
return dst;
}
private static void enableConvolveOp(RenderQueue rq,
SurfaceData srcData,
ConvolveOp cop)
{
// assert rq.lock.isHeldByCurrentThread();
boolean edgeZero =
cop.getEdgeCondition() == ConvolveOp.EDGE_ZERO_FILL;
Kernel kernel = cop.getKernel();
int kernelWidth = kernel.getWidth();
int kernelHeight = kernel.getHeight();
int kernelSize = kernelWidth * kernelHeight;
int sizeofFloat = 4;
int totalBytesRequired = 4 + 8 + 12 + (kernelSize * sizeofFloat);
RenderBuffer buf = rq.getBuffer();
rq.ensureCapacityAndAlignment(totalBytesRequired, 4);
buf.putInt(ENABLE_CONVOLVE_OP);
buf.putLong(srcData.getNativeOps());
buf.putInt(edgeZero ? 1 : 0);
buf.putInt(kernelWidth);
buf.putInt(kernelHeight);
buf.put(kernel.getKernelData(null));
}
public static void convolve(Kernel kernel, int[] inPixels, int[] outPixels,
int width, int height, boolean alpha, int edgeAction) {
if (kernel.getHeight() == 1)
convolveH(kernel, inPixels, outPixels, width, height, alpha,
edgeAction);
else if (kernel.getWidth() == 1)
convolveV(kernel, inPixels, outPixels, width, height, alpha,
edgeAction);
else
convolveHV(kernel, inPixels, outPixels, width, height, alpha,
edgeAction);
}
private void buildConvolveOpTab(JTabbedPane tabbedPane) {
BufferedImage dstImage = null;
float[] sharpen = new float[] {
0.0f, -1.0f, 0.0f,
-1.0f, 5.0f, -1.0f,
0.0f, -1.0f, 0.0f
};
Kernel kernel = new Kernel(3, 3, sharpen);
ConvolveOp op = new ConvolveOp(kernel);
dstImage = op.filter(sourceImage, null);
tabbedPane.add("Convolve", new JLabel(new ImageIcon(dstImage)));
}
public OpCompatibleImageTest() {
final Kernel kernel = new Kernel(3, 3,
new float[] {
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f});
op = new ConvolveOp(kernel);
}
private static BufferedImageOp getConvolveOp() {
int kw = 3;
int kh = 3;
int size = kw * kh;
float[] kdata = new float[size];
Arrays.fill(kdata, 1.0f / size);
Kernel k = new Kernel(kw, kh, kdata);
return new ConvolveOp(k);
}
/**************************** ConvolveOp support ****************************/
public static boolean isConvolveOpValid(ConvolveOp cop) {
Kernel kernel = cop.getKernel();
int kw = kernel.getWidth();
int kh = kernel.getHeight();
// REMIND: we currently can only handle 3x3 and 5x5 kernels,
// but hopefully this is just a temporary restriction;
// see native shader comments for more details
if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
return false;
}
return true;
}
/**************************** ConvolveOp support ****************************/
public static boolean isConvolveOpValid(ConvolveOp cop) {
Kernel kernel = cop.getKernel();
int kw = kernel.getWidth();
int kh = kernel.getHeight();
// REMIND: we currently can only handle 3x3 and 5x5 kernels,
// but hopefully this is just a temporary restriction;
// see native shader comments for more details
if (!(kw == 3 && kh == 3) && !(kw == 5 && kh == 5)) {
return false;
}
return true;
}
public OpCompatibleImageTest() {
final Kernel kernel = new Kernel(3, 3,
new float[] {
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f});
op = new ConvolveOp(kernel);
}
private static BufferedImageOp getConvolveOp() {
int kw = 3;
int kh = 3;
int size = kw * kh;
float[] kdata = new float[size];
Arrays.fill(kdata, 1.0f / size);
Kernel k = new Kernel(kw, kh, kdata);
return new ConvolveOp(k);
}
private static BufferedImageOp createTestOp() {
final int size = 1;
final float v = 1f / (size * size);
final float[] k_data = new float[size * size];
Arrays.fill(k_data, v);
Kernel k = new Kernel(size, size, k_data);
return new ConvolveOp(k);
}
ConvolveOp getBlurOp(int size) {
float[] data = new float[size * size];
float value = 1 / (float) (size * size);
for (int i = 0; i < data.length; i++) {
data[i] = value;
}
return new ConvolveOp(new Kernel(size, size, data));
}
public OpCompatibleImageTest() {
final Kernel kernel = new Kernel(3, 3,
new float[] {
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f});
op = new ConvolveOp(kernel);
}
private static BufferedImageOp getConvolveOp() {
int kw = 3;
int kh = 3;
int size = kw * kh;
float[] kdata = new float[size];
Arrays.fill(kdata, 1.0f / size);
Kernel k = new Kernel(kw, kh, kdata);
return new ConvolveOp(k);
}
ConvolveOp getBlurOp(int size) {
float[] data = new float[size * size];
float value = 1 / (float) (size * size);
for (int i = 0; i < data.length; i++) {
data[i] = value;
}
return new ConvolveOp(new Kernel(size, size, data));
}
private static BufferedImageOp getConvolveOp() {
int kw = 3;
int kh = 3;
int size = kw * kh;
float[] kdata = new float[size];
Arrays.fill(kdata, 1.0f / size);
Kernel k = new Kernel(kw, kh, kdata);
return new ConvolveOp(k);
}
private static BufferedImageOp getConvolveOp() {
int kw = 3;
int kh = 3;
int size = kw * kh;
float[] kdata = new float[size];
Arrays.fill(kdata, 1.0f / size);
Kernel k = new Kernel(kw, kh, kdata);
return new ConvolveOp(k);
}
/**
* @param bimage
*/
private static BufferedImage blurImage(final BufferedImage bimage) {
float[] fs = new float[] { 1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f,
1f / 9f, 1f / 9f, 1f / 9f, 1f / 9f };
final Kernel kernel = new Kernel(3, 3, fs);
final BufferedImageOp op = new ConvolveOp(kernel);
return op.filter(bimage, null);
}
public static ConvolveOp getBlurFilter(int horizontalRadius,
int verticalRadius) {
int width = horizontalRadius * 2 + 1;
int height = verticalRadius * 2 + 1;
float weight = 1.0f / (width * height);
float[] data = new float[width * height];
for (int i = 0; i < data.length; i++) {
data[i] = weight;
}
Kernel kernel = new Kernel(width, height, data);
return new ConvolveOp(kernel, ConvolveOp.EDGE_NO_OP, null);
}
private static BufferedImageOp createTestOp() {
final int size = 1;
final float v = 1f / (size * size);
final float[] k_data = new float[size * size];
Arrays.fill(k_data, v);
Kernel k = new Kernel(size, size, k_data);
return new ConvolveOp(k);
}
public OpCompatibleImageTest() {
final Kernel kernel = new Kernel(3, 3,
new float[] {
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f,
1f/9f, 1f/9f, 1f/9f});
op = new ConvolveOp(kernel);
}
private static BufferedImageOp getConvolveOp() {
int kw = 3;
int kh = 3;
int size = kw * kh;
float[] kdata = new float[size];
Arrays.fill(kdata, 1.0f / size);
Kernel k = new Kernel(kw, kh, kdata);
return new ConvolveOp(k);
}