Java Code Examples for java.awt.image.Kernel#getHeight()
The following examples show how to use
java.awt.image.Kernel#getHeight() .
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
| Source File: BufferedBufImgOps.java From dragonwell8_jdk with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 2
| Source File: BufferedBufImgOps.java From jdk8u-jdk with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 3
| Source File: BufferedBufImgOps.java From jdk8u_jdk with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 4
| Source File: BufferedBufImgOps.java From openjdk-8 with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 5
| Source File: BufferedBufImgOps.java From Bytecoder with Apache License 2.0 | 6 votes |
|
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));
}
Example 6
| Source File: BufferedBufImgOps.java From openjdk-jdk8u-backup with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 7
| Source File: BufferedBufImgOps.java From openjdk-jdk8u with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 8
| Source File: BufferedBufImgOps.java From jdk8u60 with GNU General Public License v2.0 | 6 votes |
|
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));
}
Example 9
| Source File: ConvolveFilter.java From weblaf with GNU General Public License v3.0 | 5 votes |
|
public static void convolve ( final Kernel kernel, final int[] inPixels, final int[] outPixels, final int width, final int height, final boolean alpha, final 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 );
}
}
Example 10
| Source File: BufferedBufImgOps.java From openjdk-jdk9 with GNU General Public License v2.0 | 5 votes |
|
/**************************** 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;
}
Example 11
| Source File: BufferedBufImgOps.java From jdk8u-dev-jdk with GNU General Public License v2.0 | 5 votes |
|
/**************************** 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;
}
Example 12
| Source File: BufferedBufImgOps.java From hottub with GNU General Public License v2.0 | 5 votes |
|
/**************************** 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;
}
Example 13
| Source File: BufferedBufImgOps.java From openjdk-8 with GNU General Public License v2.0 | 5 votes |
|
/**************************** 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;
}
Example 14
| Source File: BufferedBufImgOps.java From dragonwell8_jdk with GNU General Public License v2.0 | 5 votes |
|
/**************************** 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;
}
Example 15
| Source File: ConvolveFilter.java From weblaf with GNU General Public License v3.0 | 4 votes |
|
/**
* Convolve with a kernel consisting of one column
*/
public static void convolveV ( final Kernel kernel, final int[] inPixels, final int[] outPixels, final int width, final int height, final boolean alpha, final int edgeAction )
{
int index = 0;
final float[] matrix = kernel.getKernelData ( null );
final int rows = kernel.getHeight ();
final int rows2 = rows / 2;
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++ )
{
float r = 0, g = 0, b = 0, a = 0;
for ( int row = -rows2; row <= rows2; row++ )
{
final int iy = y + row;
final int iOffset;
if ( iy < 0 )
{
if ( edgeAction == CLAMP_EDGES )
{
iOffset = 0;
}
else if ( edgeAction == WRAP_EDGES )
{
iOffset = ( ( y + height ) % height ) * width;
}
else
{
iOffset = iy * width;
}
}
else if ( iy >= height )
{
if ( edgeAction == CLAMP_EDGES )
{
iOffset = ( height - 1 ) * width;
}
else if ( edgeAction == WRAP_EDGES )
{
iOffset = ( ( y + height ) % height ) * width;
}
else
{
iOffset = iy * width;
}
}
else
{
iOffset = iy * width;
}
final float f = matrix[ row + rows2 ];
if ( f != 0 )
{
final int rgb = inPixels[ iOffset + x ];
a += f * ( ( rgb >> 24 ) & 0xff );
r += f * ( ( rgb >> 16 ) & 0xff );
g += f * ( ( rgb >> 8 ) & 0xff );
b += f * ( rgb & 0xff );
}
}
final int ia = alpha ? PixelUtils.clamp ( ( int ) ( a + 0.5 ) ) : 0xff;
final int ir = PixelUtils.clamp ( ( int ) ( r + 0.5 ) );
final int ig = PixelUtils.clamp ( ( int ) ( g + 0.5 ) );
final int ib = PixelUtils.clamp ( ( int ) ( b + 0.5 ) );
outPixels[ index++ ] = ( ia << 24 ) | ( ir << 16 ) | ( ig << 8 ) | ib;
}
}
}
Example 16
| Source File: ConvolveFilter.java From weblaf with GNU General Public License v3.0 | 4 votes |
|
/**
* Convolve with a 2D kernel
*/
public static void convolveHV ( final Kernel kernel, final int[] inPixels, final int[] outPixels, final int width, final int height, final boolean alpha, final int edgeAction )
{
int index = 0;
final float[] matrix = kernel.getKernelData ( null );
final int rows = kernel.getHeight ();
final int cols = kernel.getWidth ();
final int rows2 = rows / 2;
final int cols2 = cols / 2;
for ( int y = 0; y < height; y++ )
{
for ( int x = 0; x < width; x++ )
{
float r = 0, g = 0, b = 0, a = 0;
for ( int row = -rows2; row <= rows2; row++ )
{
final int iy = y + row;
final int iOffset;
if ( 0 <= iy && iy < height )
{
iOffset = iy * width;
}
else if ( edgeAction == CLAMP_EDGES )
{
iOffset = y * width;
}
else if ( edgeAction == WRAP_EDGES )
{
iOffset = ( ( iy + height ) % height ) * width;
}
else
{
continue;
}
final int mOffset = cols * ( row + rows2 ) + cols2;
for ( int col = -cols2; col <= cols2; col++ )
{
final float f = matrix[ mOffset + col ];
if ( f != 0 )
{
int ix = x + col;
if ( !( 0 <= ix && ix < width ) )
{
if ( edgeAction == CLAMP_EDGES )
{
ix = x;
}
else if ( edgeAction == WRAP_EDGES )
{
ix = ( x + width ) % width;
}
else
{
continue;
}
}
final int rgb = inPixels[ iOffset + ix ];
a += f * ( ( rgb >> 24 ) & 0xff );
r += f * ( ( rgb >> 16 ) & 0xff );
g += f * ( ( rgb >> 8 ) & 0xff );
b += f * ( rgb & 0xff );
}
}
}
final int ia = alpha ? PixelUtils.clamp ( ( int ) ( a + 0.5 ) ) : 0xff;
final int ir = PixelUtils.clamp ( ( int ) ( r + 0.5 ) );
final int ig = PixelUtils.clamp ( ( int ) ( g + 0.5 ) );
final int ib = PixelUtils.clamp ( ( int ) ( b + 0.5 ) );
outPixels[ index++ ] = ( ia << 24 ) | ( ir << 16 ) | ( ig << 8 ) | ib;
}
}
}
Example 17
| Source File: ConvolveFilter.java From pumpernickel with MIT License | 4 votes |
|
/**
* Convolve with a kernel consisting of one column
*
* @param kernel
* the kernel to apply
* @param inPixels
* the input pixels
* @param outPixels
* the output pixels
* @param width
* the width of the image
* @param height
* the height of the image
* @param alpha
* whether alpha is present
* @param edgeAction
* one of the edge constants
*/
public static void convolveV(Kernel kernel, int[] inPixels,
int[] outPixels, int width, int height, boolean alpha,
int edgeAction) {
int index = 0;
float[] matrix = kernel.getKernelData(null);
int rows = kernel.getHeight();
int rows2 = rows / 2;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y + row;
int ioffset;
if (iy < 0) {
if (edgeAction == CLAMP_EDGES)
ioffset = 0;
else if (edgeAction == WRAP_EDGES)
ioffset = ((y + height) % height) * width;
else
ioffset = iy * width;
} else if (iy >= height) {
if (edgeAction == CLAMP_EDGES)
ioffset = (height - 1) * width;
else if (edgeAction == WRAP_EDGES)
ioffset = ((y + height) % height) * width;
else
ioffset = iy * width;
} else
ioffset = iy * width;
float f = matrix[row + rows2];
if (f != 0) {
int rgb = inPixels[ioffset + x];
a += f * ((rgb >> 24) & 0xff);
r += f * ((rgb >> 16) & 0xff);
g += f * ((rgb >> 8) & 0xff);
b += f * (rgb & 0xff);
}
}
int ia = alpha ? PixelUtils.clamp((int) (a + 0.5)) : 0xff;
int ir = PixelUtils.clamp((int) (r + 0.5));
int ig = PixelUtils.clamp((int) (g + 0.5));
int ib = PixelUtils.clamp((int) (b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
Example 18
| Source File: ConvolveFilter.java From openbd-core with GNU General Public License v3.0 | 4 votes |
|
/**
* Convolve with a kernel consisting of one column.
* @param kernel the kernel
* @param inPixels the input pixels
* @param outPixels the output pixels
* @param width the width
* @param height the height
* @param alpha include alpha channel
* @param edgeAction what to do at the edges
*/
public static void convolveV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
int index = 0;
float[] matrix = kernel.getKernelData( null );
int rows = kernel.getHeight();
int rows2 = rows/2;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y+row;
int ioffset;
if ( iy < 0 ) {
if ( edgeAction == CLAMP_EDGES )
ioffset = 0;
else if ( edgeAction == WRAP_EDGES )
ioffset = ((y+height) % height)*width;
else
ioffset = iy*width;
} else if ( iy >= height) {
if ( edgeAction == CLAMP_EDGES )
ioffset = (height-1)*width;
else if ( edgeAction == WRAP_EDGES )
ioffset = ((y+height) % height)*width;
else
ioffset = iy*width;
} else
ioffset = iy*width;
float f = matrix[row+rows2];
if (f != 0) {
int rgb = inPixels[ioffset+x];
a += f * ((rgb >> 24) & 0xff);
r += f * ((rgb >> 16) & 0xff);
g += f * ((rgb >> 8) & 0xff);
b += f * (rgb & 0xff);
}
}
int ia = alpha ? PixelUtils.clamp((int)(a+0.5)) : 0xff;
int ir = PixelUtils.clamp((int)(r+0.5));
int ig = PixelUtils.clamp((int)(g+0.5));
int ib = PixelUtils.clamp((int)(b+0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
Example 19
| Source File: ConvolveFilter.java From Pixelitor with GNU General Public License v3.0 | 4 votes |
|
/**
* Convolve with a kernel consisting of one column.
*
* @param kernel the kernel
* @param inPixels the input pixels
* @param outPixels the output pixels
* @param width the width
* @param height the height
* @param alpha include alpha channel
* @param edgeAction what to do at the edges
*/
public static void convolveV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
int index = 0;
float[] matrix = kernel.getKernelData(null);
int rows = kernel.getHeight();
int rows2 = rows / 2;
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y + row;
int ioffset;
if (iy < 0) {
if (edgeAction == CLAMP_EDGES) {
ioffset = 0;
} else if (edgeAction == WRAP_EDGES) {
ioffset = ((y + height) % height) * width;
} else {
ioffset = iy * width;
}
} else if (iy >= height) {
if (edgeAction == CLAMP_EDGES) {
ioffset = (height - 1) * width;
} else if (edgeAction == WRAP_EDGES) {
ioffset = ((y + height) % height) * width;
} else {
ioffset = iy * width;
}
} else {
ioffset = iy * width;
}
float f = matrix[row + rows2];
if (f != 0) {
int rgb = inPixels[ioffset + x];
a += f * ((rgb >> 24) & 0xff);
r += f * ((rgb >> 16) & 0xff);
g += f * ((rgb >> 8) & 0xff);
b += f * (rgb & 0xff);
}
}
int ia = alpha ? PixelUtils.clamp((int) (a + 0.5)) : 0xff;
int ir = PixelUtils.clamp((int) (r + 0.5));
int ig = PixelUtils.clamp((int) (g + 0.5));
int ib = PixelUtils.clamp((int) (b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
}
}
Example 20
| Source File: ConvolveFilter.java From Pixelitor with GNU General Public License v3.0 | 4 votes |
|
/**
* Convolve with a 2D kernel.
*
* @param kernel the kernel
* @param inPixels the input pixels
* @param outPixels the output pixels
* @param width the width
* @param height the height
* @param alpha include alpha channel
* @param edgeAction what to do at the edges
*/
public void convolveHV(Kernel kernel, int[] inPixels, int[] outPixels, int width, int height, boolean alpha, int edgeAction) {
int index = 0;
float[] matrix = kernel.getKernelData(null);
int rows = kernel.getHeight();
int cols = kernel.getWidth();
int rows2 = rows / 2;
int cols2 = cols / 2;
pt = createProgressTracker(height);
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
float r = 0, g = 0, b = 0, a = 0;
for (int row = -rows2; row <= rows2; row++) {
int iy = y + row;
int ioffset;
if (0 <= iy && iy < height) {
ioffset = iy * width;
} else if (edgeAction == CLAMP_EDGES) {
ioffset = y * width;
} else if (edgeAction == WRAP_EDGES) {
ioffset = ((iy + height) % height) * width;
} else {
continue;
}
int moffset = cols * (row + rows2) + cols2;
for (int col = -cols2; col <= cols2; col++) {
float f = matrix[moffset + col];
if (f != 0) {
int ix = x + col;
if (!(0 <= ix && ix < width)) {
if (edgeAction == CLAMP_EDGES) {
ix = x;
} else if (edgeAction == WRAP_EDGES) {
ix = (x + width) % width;
} else {
continue;
}
}
int rgb = inPixels[ioffset + ix];
a += f * ((rgb >> 24) & 0xff);
r += f * ((rgb >> 16) & 0xff);
g += f * ((rgb >> 8) & 0xff);
b += f * (rgb & 0xff);
}
}
}
int ia = alpha ? PixelUtils.clamp((int) (a + 0.5)) : 0xff;
int ir = PixelUtils.clamp((int) (r + 0.5));
int ig = PixelUtils.clamp((int) (g + 0.5));
int ib = PixelUtils.clamp((int) (b + 0.5));
outPixels[index++] = (ia << 24) | (ir << 16) | (ig << 8) | ib;
}
pt.unitDone();
}
finishProgressTracker();
}
