public static void process(GrayS16 orig, GrayS16 derivX, GrayS16 derivY) { final short[] data = orig.data; final short[] imgX = derivX.data; final short[] imgY = derivY.data; final int width = orig.getWidth(); final int height = orig.getHeight(); final int stride = orig.stride; for (int y = 1; y < height; y++) { int indexX = derivX.startIndex + derivX.stride * y + 1; int indexY = derivY.startIndex + derivY.stride * y + 1; int indexSrc = orig.startIndex + stride * y + 1; final int endX = indexSrc + width - 1; for (; indexSrc < endX; indexSrc++) { int val = data[indexSrc]; imgX[indexX++] = (short) (val - data[indexSrc - 1]); imgY[indexY++] = (short) (val - data[indexSrc - stride]); } } }
public static void process(GrayS16 orig, GrayS16 derivX, GrayS16 derivY) { final short[] data = orig.data; final short[] imgX = derivX.data; final short[] imgY = derivY.data; final int width = orig.getWidth(); final int height = orig.getHeight() - 1; final int stride = orig.stride; for (int y = 0; y < height; y++) { int indexX = derivX.startIndex + derivX.stride * y; int indexY = derivY.startIndex + derivY.stride * y; int indexSrc = orig.startIndex + stride * y; final int endX = indexSrc + width - 1; for (; indexSrc < endX; indexSrc++) { int val = data[indexSrc]; imgX[indexX++] = (short) (data[indexSrc + 1] - val); imgY[indexY++] = (short) (data[indexSrc + stride] - val); } } }
public static void process(GrayS16 orig, GrayS16 derivX, GrayS16 derivY) { final short[] data = orig.data; final short[] imgX = derivX.data; final short[] imgY = derivY.data; final int width = orig.getWidth(); final int height = orig.getHeight() - 1; final int stride = orig.stride; for (int y = 1; y < height; y++) { int indexX = derivX.startIndex + derivX.stride * y + 1; int indexY = derivY.startIndex + derivY.stride * y + 1; int indexSrc = orig.startIndex + stride * y + 1; final int endX = indexSrc + width - 2; for (; indexSrc < endX; indexSrc++) { imgX[indexX++] = (short) (data[indexSrc + 1] - data[indexSrc - 1]); imgY[indexY++] = (short) (data[indexSrc + stride] - data[indexSrc - stride]); } } }
public static void horizontal3(Kernel1D_S32 kernel , GrayS16 image, GrayI16 dest ) { final short[] dataSrc = image.data; final short[] dataDst = dest.data; final int k1 = kernel.data[0]; final int k2 = kernel.data[1]; final int k3 = kernel.data[2]; final int radius = kernel.getRadius(); final int width = image.getWidth(); for( int i = 0; i < image.height; i++ ) { int indexDst = dest.startIndex + i*dest.stride+radius; int j = image.startIndex + i*image.stride - radius; final int jEnd = j+width-radius; for( j += radius; j < jEnd; j++ ) { int indexSrc = j; int total = (dataSrc[indexSrc++])*k1; total += (dataSrc[indexSrc++])*k2; total += (dataSrc[indexSrc])*k3; dataDst[indexDst++] = ( short )total; } } }
public static void horizontal3(Kernel1D_S32 kernel , GrayS16 image, GrayI16 dest , int divisor ) { final short[] dataSrc = image.data; final short[] dataDst = dest.data; final int k1 = kernel.data[0]; final int k2 = kernel.data[1]; final int k3 = kernel.data[2]; final int radius = kernel.getRadius(); final int width = image.getWidth(); final int halfDivisor = divisor/2; for( int i = 0; i < image.height; i++ ) { int indexDst = dest.startIndex + i*dest.stride+radius; int j = image.startIndex + i*image.stride - radius; final int jEnd = j+width-radius; for( j += radius; j < jEnd; j++ ) { int indexSrc = j; int total = (dataSrc[indexSrc++])*k1; total += (dataSrc[indexSrc++])*k2; total += (dataSrc[indexSrc])*k3; dataDst[indexDst++] = ( short )((total+halfDivisor)/divisor); } } }
public static void convolve(Kernel2D_S32 kernel , GrayS16 src , GrayI16 dest , int divisor ) { final int[] dataKernel = kernel.data; final short[] dataSrc = src.data; final short[] dataDst = dest.data; final int width = src.getWidth(); final int height = src.getHeight(); final int halfDivisor = divisor/2; int offsetL = kernel.offset; int offsetR = kernel.width-kernel.offset-1; for( int y = offsetL; y < height-offsetR; y++ ) { int indexDst = dest.startIndex + y*dest.stride+offsetL; for( int x = offsetL; x < width-offsetR; x++ ) { int total = 0; int indexKer = 0; for( int ki = 0; ki < kernel.width; ki++ ) { int indexSrc = src.startIndex + (y+ki-offsetL)*src.stride + x-offsetL; for( int kj = 0; kj < kernel.width; kj++ ) { total += (dataSrc[indexSrc+kj] )* dataKernel[indexKer++]; } } dataDst[indexDst++] = (short)((total+halfDivisor)/divisor); } } }
public static void horizontal5(Kernel1D_S32 kernel , GrayS16 image, GrayI16 dest ) { final short[] dataSrc = image.data; final short[] dataDst = dest.data; final int k1 = kernel.data[0]; final int k2 = kernel.data[1]; final int k3 = kernel.data[2]; final int k4 = kernel.data[3]; final int k5 = kernel.data[4]; final int radius = kernel.getRadius(); final int width = image.getWidth(); for( int i = 0; i < image.height; i++ ) { int indexDst = dest.startIndex + i*dest.stride+radius; int j = image.startIndex + i*image.stride - radius; final int jEnd = j+width-radius; for( j += radius; j < jEnd; j++ ) { int indexSrc = j; int total = (dataSrc[indexSrc++])*k1; total += (dataSrc[indexSrc++])*k2; total += (dataSrc[indexSrc++])*k3; total += (dataSrc[indexSrc++])*k4; total += (dataSrc[indexSrc])*k5; dataDst[indexDst++] = ( short )total; } } }
public static void convolve(Kernel2D_S32 kernel , GrayS16 src , GrayI16 dest ) { final int[] dataKernel = kernel.data; final short[] dataSrc = src.data; final short[] dataDst = dest.data; final int width = src.getWidth(); final int height = src.getHeight(); int offsetL = kernel.offset; int offsetR = kernel.width-kernel.offset-1; for( int y = offsetL; y < height-offsetR; y++ ) { int indexDst = dest.startIndex + y*dest.stride+offsetL; for( int x = offsetL; x < width-offsetR; x++ ) { int total = 0; int indexKer = 0; for( int ki = 0; ki < kernel.width; ki++ ) { int indexSrc = src.startIndex + (y+ki-offsetL)*src.stride + x-offsetL; for( int kj = 0; kj < kernel.width; kj++ ) { total += (dataSrc[indexSrc+kj] )* dataKernel[indexKer++]; } } dataDst[indexDst++] = (short)total; } } }
public static void horizontal5(Kernel1D_S32 kernel , GrayS16 image, GrayI16 dest , int divisor ) { final short[] dataSrc = image.data; final short[] dataDst = dest.data; final int k1 = kernel.data[0]; final int k2 = kernel.data[1]; final int k3 = kernel.data[2]; final int k4 = kernel.data[3]; final int k5 = kernel.data[4]; final int radius = kernel.getRadius(); final int width = image.getWidth(); final int halfDivisor = divisor/2; for( int i = 0; i < image.height; i++ ) { int indexDst = dest.startIndex + i*dest.stride+radius; int j = image.startIndex + i*image.stride - radius; final int jEnd = j+width-radius; for( j += radius; j < jEnd; j++ ) { int indexSrc = j; int total = (dataSrc[indexSrc++])*k1; total += (dataSrc[indexSrc++])*k2; total += (dataSrc[indexSrc++])*k3; total += (dataSrc[indexSrc++])*k4; total += (dataSrc[indexSrc])*k5; dataDst[indexDst++] = ( short )((total+halfDivisor)/divisor); } } }
public static void horizontal( Kernel1D_S32 kernel , GrayS16 image, GrayI16 dest ) { final short[] dataSrc = image.data; final short[] dataDst = dest.data; final int[] dataKer = kernel.data; final int offset = kernel.getOffset(); final int kernelWidth = kernel.getWidth(); final int width = image.getWidth(); for( int i = 0; i < image.height; i++ ) { int indexDst = dest.startIndex + i*dest.stride+offset; int j = image.startIndex + i*image.stride; final int jEnd = j+width-(kernelWidth-1); for( ; j < jEnd; j++ ) { int total = 0; int indexSrc = j; for( int k = 0; k < kernelWidth; k++ ) { total += (dataSrc[indexSrc++] ) * dataKer[k]; } dataDst[indexDst++] = (short)total; } } }
public static void horizontal( Kernel1D_S32 kernel , GrayS16 image, GrayI16 dest , int divisor ) { final short[] dataSrc = image.data; final short[] dataDst = dest.data; final int[] dataKer = kernel.data; final int offset = kernel.getOffset(); final int kernelWidth = kernel.getWidth(); final int halfDivisor = divisor/2; final int width = image.getWidth(); for( int i = 0; i < image.height; i++ ) { int indexDst = dest.startIndex + i*dest.stride+offset; int j = image.startIndex + i*image.stride; final int jEnd = j+width-(kernelWidth-1); for( ; j < jEnd; j++ ) { int total = 0; int indexSrc = j; for( int k = 0; k < kernelWidth; k++ ) { total += (dataSrc[indexSrc++] ) * dataKer[k]; } dataDst[indexDst++] = (short)((total+halfDivisor)/divisor); } } }
public static void process(GrayS16 orig, GrayS16 derivX, GrayS16 derivY) { final short[] data = orig.data; final short[] imgX = derivX.data; final short[] imgY = derivY.data; final int width = orig.getWidth(); final int height = orig.getHeight() - 1; final int strideSrc = orig.getStride(); for (int y = 1; y < height; y++) { int indexSrc = orig.startIndex + orig.stride * y + 1; final int endX = indexSrc + width - 2; int indexX = derivX.startIndex + derivX.stride * y + 1; int indexY = derivY.startIndex + derivY.stride * y + 1; for (; indexSrc < endX; indexSrc++) { // a33 - a11 int w = (data[indexSrc + strideSrc + 1] ) -(data[indexSrc - strideSrc - 1] ); // a31 - a13 int v = (data[indexSrc + strideSrc - 1] ) -(data[indexSrc - strideSrc + 1] ); //a32 + w + v - a12 imgY[indexY++] = (short) ((data[indexSrc + strideSrc ] )+w+v-(data[indexSrc - strideSrc ] )); //a23 + w - v - a21 imgX[indexX++] = (short) ((data[indexSrc + 1] )+w-v-(data[indexSrc - 1] )); } } }
public static void process_I8_sub(GrayS16 orig, GrayS16 derivX, GrayS16 derivY) { final short[] data = orig.data; final short[] imgX = derivX.data; final short[] imgY = derivY.data; final int width = orig.getWidth(); final int height = orig.getHeight() - 1; final int strideSrc = orig.getStride(); for (int y = 1; y < height; y++) { int indexSrc = orig.startIndex + orig.stride * y + 1; final int endX = indexSrc + width - 2; int indexX = derivX.startIndex + derivX.stride * y + 1; int indexY = derivY.startIndex + derivY.stride * y + 1; for (; indexSrc < endX; indexSrc++) { int v = (data[indexSrc + strideSrc + 1] ) - (data[indexSrc - strideSrc - 1] ); int w = (data[indexSrc + strideSrc - 1] ) - (data[indexSrc - strideSrc + 1] ); imgY[indexY++] = (short) (((data[indexSrc + strideSrc] ) - (data[indexSrc - strideSrc] )) * 2 + v + w); imgX[indexX++] = (short) (((data[indexSrc + 1] ) - (data[indexSrc - 1] )) * 2 + v - w); } } }
/** * Bounds image pixels to be between these two values * * @param img Image * @param min minimum value. * @param max maximum value. */ public static void boundImage(GrayS16 img , int min , int max ) { final int h = img.getHeight(); final int w = img.getWidth(); short[] data = img.data; for (int y = 0; y < h; y++) { int index = img.getStartIndex() + y * img.getStride(); int indexEnd = index+w; // for(int x = 0; x < w; x++ ) { for (; index < indexEnd; index++) { int value = data[index]; if( value < min ) data[index] = (short)min; else if( value > max ) data[index] = (short)max; } } }
public static void vertical(Kernel1D_S32 kernel, GrayS16 input, GrayI16 output ) { final int offset = kernel.getOffset(); final int width = input.getWidth(); final int height = input.getHeight(); for (int y = 0; y < height; y++) { for( int x = 0; x < width; x++ ) { int total = 0; int weight = 0; int startY = y - offset; int endY = startY + kernel.getWidth(); if( startY < 0 ) startY = 0; if( endY > height ) endY = height; for( int i = startY; i < endY; i++ ) { int v = kernel.get(i-y+offset); total += input.get(x,i)*v; weight += v; } output.set(x,y, (total+weight/2)/weight ); } } }
/** * <p> * Computes the absolute value of the difference between each pixel in the two images.<br> * d(x,y) = |img1(x,y) - img2(x,y)| * </p> * @param imgA Input image. Not modified. * @param imgB Input image. Not modified. * @param diff Absolute value of difference image. Modified. */ public static void diffAbs(GrayS16 imgA , GrayS16 imgB , GrayS16 diff ) { InputSanityCheck.checkSameShape(imgA,imgB,diff); final int h = imgA.getHeight(); final int w = imgA.getWidth(); for (int y = 0; y < h; y++) { int indexA = imgA.getStartIndex() + y * imgA.getStride(); int indexB = imgB.getStartIndex() + y * imgB.getStride(); int indexDiff = diff.getStartIndex() + y * diff.getStride(); int indexEnd = indexA+w; // for(int x = 0; x < w; x++ ) { for (; indexA < indexEnd; indexA++, indexB++, indexDiff++ ) { diff.data[indexDiff] = (short)Math.abs((imgA.data[indexA] ) - (imgB.data[indexB] )); } } }
public static void horizontal(Kernel1D_S32 kernel, GrayS16 input, GrayI16 output ) { final int offset = kernel.getOffset(); final int width = input.getWidth(); final int height = input.getHeight(); for (int y = 0; y < height; y++) { for( int x = 0; x < width; x++ ) { int total = 0; int weight = 0; int startX = x - offset; int endX = startX+kernel.getWidth(); if( startX < 0 ) startX = 0; if( endX > width ) endX = width; for( int j = startX; j < endX; j++ ) { int v = kernel.get(j-x+offset); total += input.get(j,y)*v; weight += v; } output.set(x,y, (total+weight/2)/weight ); } } }
public static void convolve(Kernel2D_S32 kernel, GrayS16 input, GrayI16 output ) { final int offset = kernel.getOffset(); final int width = input.getWidth(); final int height = input.getHeight(); for (int y = 0; y < height; y++) { for( int x = 0; x < width; x++ ) { int startX = x - offset; int endX = startX + kernel.getWidth(); if( startX < 0 ) startX = 0; if( endX > width ) endX = width; int startY = y - offset; int endY = startY + kernel.getWidth(); if( startY < 0 ) startY = 0; if( endY > height ) endY = height; int total = 0; int weight = 0; for( int i = startY; i < endY; i++ ) { for( int j = startX; j < endX; j++ ) { int v = kernel.get(j-x+offset,i-y+offset); total += input.get(j,i)*v; weight += v; } } output.set(x,y, (total+weight/2)/weight ); } } }
/** * <p> * Performs pixel-wise addition<br> * output(x,y) = imgA(x,y) + imgB(x,y) * </p> * @param imgA Input image. Not modified. * @param imgB Input image. Not modified. * @param output Output image. Modified. */ public static void add(GrayS16 imgA , GrayS16 imgB , GrayS32 output ) { InputSanityCheck.checkSameShape(imgA,imgB,output); final int h = imgA.getHeight(); final int w = imgA.getWidth(); for (int y = 0; y < h; y++) { int indexA = imgA.getStartIndex() + y * imgA.getStride(); int indexB = imgB.getStartIndex() + y * imgB.getStride(); int indexOut = output.getStartIndex() + y * output.getStride(); int indexEnd = indexA+w; // for(int x = 0; x < w; x++ ) { for (; indexA < indexEnd; indexA++, indexB++, indexOut++ ) { output.data[indexOut] = (int)((imgA.data[indexA] ) + (imgB.data[indexB] )); } } }
/** * <p> * Performs pixel-wise subtraction.<br> * output(x,y) = imgA(x,y) - imgB(x,y) * </p> * @param imgA Input image. Not modified. * @param imgB Input image. Not modified. * @param output Output image. Modified. */ public static void subtract(GrayS16 imgA , GrayS16 imgB , GrayS32 output ) { InputSanityCheck.checkSameShape(imgA,imgB,output); final int h = imgA.getHeight(); final int w = imgA.getWidth(); for (int y = 0; y < h; y++) { int indexA = imgA.getStartIndex() + y * imgA.getStride(); int indexB = imgB.getStartIndex() + y * imgB.getStride(); int indexOut = output.getStartIndex() + y * output.getStride(); int indexEnd = indexA+w; // for(int x = 0; x < w; x++ ) { for (; indexA < indexEnd; indexA++, indexB++, indexOut++ ) { output.data[indexOut] = (int)((imgA.data[indexA] ) - (imgB.data[indexB] )); } } }