public static void vertical(Kernel1D_F32 kernel, GrayF32 input, GrayF32 output) {
final float[] dataSrc = input.data;
final float[] dataDst = output.data;
final float[] dataKer = kernel.data;
final int kernelWidth = kernel.getWidth();
final int offsetL = kernel.getOffset();
final int offsetR = kernelWidth - offsetL - 1;
final int imgWidth = output.getWidth();
final int imgHeight = output.getHeight();
final int yEnd = imgHeight - offsetR;
for (int y = 0; y < offsetL; y++) {
int indexDst = output.startIndex + y * output.stride;
int i = input.startIndex + y * input.stride;
final int iEnd = i + imgWidth;
int kStart = offsetL - y;
float weight = 0;
for (int k = kStart; k < kernelWidth; k++) {
weight += dataKer[k];
}
for (; i < iEnd; i++) {
float total = 0;
int indexSrc = i - y * input.stride;
for (int k = kStart; k < kernelWidth; k++, indexSrc += input.stride) {
total += (dataSrc[indexSrc]) * dataKer[k];
}
dataDst[indexDst++] = (total / weight);
}
}
for (int y = yEnd; y < imgHeight; y++) {
int indexDst = output.startIndex + y * output.stride;
int i = input.startIndex + y * input.stride;
final int iEnd = i + imgWidth;
int kEnd = imgHeight - (y - offsetL);
float weight = 0;
for (int k = 0; k < kEnd; k++) {
weight += dataKer[k];
}
for (; i < iEnd; i++) {
float total = 0;
int indexSrc = i - offsetL * input.stride;
for (int k = 0; k < kEnd; k++, indexSrc += input.stride) {
total += (dataSrc[indexSrc]) * dataKer[k];
}
dataDst[indexDst++] = (total / weight);
}
}
}
public static void horizontal(Kernel1D_F32 kernel, GrayF32 input, GrayF32 output) {
final float[] dataSrc = input.data;
final float[] dataDst = output.data;
final float[] dataKer = kernel.data;
final int kernelWidth = kernel.getWidth();
final int offsetL = kernel.getOffset();
final int offsetR = kernelWidth - offsetL - 1;
final int width = input.getWidth();
final int height = input.getHeight();
for (int i = 0; i < height; i++) {
int indexDest = output.startIndex + i * output.stride;
int j = input.startIndex + i * input.stride;
final int jStart = j;
int jEnd = j + offsetL;
for (; j < jEnd; j++) {
float total = 0;
float weight = 0;
int indexSrc = jStart;
for (int k = kernelWidth - (offsetR + 1 + j - jStart); k < kernelWidth; k++) {
float w = dataKer[k];
weight += w;
total += (dataSrc[indexSrc++]) * w;
}
dataDst[indexDest++] = (total / weight);
}
j += width - (offsetL + offsetR);
indexDest += width - (offsetL + offsetR);
jEnd = jStart + width;
for (; j < jEnd; j++) {
float total = 0;
float weight = 0;
int indexSrc = j - offsetL;
final int kEnd = jEnd - indexSrc;
for (int k = 0; k < kEnd; k++) {
float w = dataKer[k];
weight += w;
total += (dataSrc[indexSrc++]) * w;
}
dataDst[indexDest++] = (total / weight);
}
}
}
public static void convolve(Kernel2D_F32 kernel, GrayF32 input, GrayF32 output) {
final float[] dataSrc = input.data;
final float[] dataDst = output.data;
final float[] dataKer = kernel.data;
final int kernelWidth = kernel.getWidth();
final int offsetL = kernel.getOffset();
final int offsetR = kernelWidth - offsetL - 1;
final int width = input.getWidth();
final int height = input.getHeight();
// convolve across the left and right borders
for (int y = 0; y < height; y++) {
int minI = y >= offsetL ? -offsetL : -y;
int maxI = y < height - offsetR ? offsetR : height - y - 1;
int indexDst = output.startIndex + y * output.stride;
for (int x = 0; x < offsetL; x++) {
float total = 0;
float weight = 0;
for (int i = minI; i <= maxI; i++) {
int indexSrc = input.startIndex + (y + i) * input.stride + x;
int indexKer = (i + offsetL) * kernelWidth;
for (int j = -x; j <= offsetR; j++) {
float w = dataKer[indexKer + j + offsetL];
weight += w;
total += (dataSrc[indexSrc + j]) * w;
}
}
dataDst[indexDst++] = (total / weight);
}
indexDst = output.startIndex + y * output.stride + width - offsetR;
for (int x = width - offsetR; x < width; x++) {
int maxJ = width - x - 1;
float total = 0;
float weight = 0;
for (int i = minI; i <= maxI; i++) {
int indexSrc = input.startIndex + (y + i) * input.stride + x;
int indexKer = (i + offsetL) * kernelWidth;
for (int j = -offsetL; j <= maxJ; j++) {
float w = dataKer[indexKer + j + offsetL];
weight += w;
total += (dataSrc[indexSrc + j]) * w;
}
}
dataDst[indexDst++] = (total / weight);
}
}
// convolve across the top border while avoiding convolving the corners again
for (int y = 0; y < offsetL; y++) {
int indexDst = output.startIndex + y * output.stride + offsetL;
for (int x = offsetL; x < width - offsetR; x++) {
float total = 0;
float weight = 0;
for (int i = -y; i <= offsetR; i++) {
int indexSrc = input.startIndex + (y + i) * input.stride + x;
int indexKer = (i + offsetL) * kernelWidth;
for (int j = -offsetL; j <= offsetR; j++) {
float w = dataKer[indexKer + j + offsetL];
weight += w;
total += (dataSrc[indexSrc + j]) * w;
}
}
dataDst[indexDst++] = (total / weight);
}
}
// convolve across the bottom border
for (int y = height - offsetR; y < height; y++) {
int maxI = height - y - 1;
int indexDst = output.startIndex + y * output.stride + offsetL;
for (int x = offsetL; x < width - offsetR; x++) {
float total = 0;
float weight = 0;
for (int i = -offsetL; i <= maxI; i++) {
int indexSrc = input.startIndex + (y + i) * input.stride + x;
int indexKer = (i + offsetL) * kernelWidth;
for (int j = -offsetL; j <= offsetR; j++) {
float w = dataKer[indexKer + j + offsetL];
weight += w;
total += (dataSrc[indexSrc + j]) * w;
}
}
dataDst[indexDst++] = (total / weight);
}
}
}
