Java ImageFloat32.getHeight方法代码示例

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static double computeWeightedError(ImageFloat32 imgA, ImageFloat32 imgB ,
										  ImageFloat32 imgWeight ) {
	final int h = imgA.getHeight();
	final int w = imgA.getWidth();

	double total = 0;
	double totalWeight = 0;

	for (int y = 0; y < h; y++) {
		for (int x = 0; x < w; x++) {
			float weight = imgWeight.get(x,y);
			double difference =  Math.abs(imgA.get(x,y)-imgB.get(x,y));
			total += difference*weight;
			totalWeight += weight;
		}
	}

	return total / totalWeight;
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Computes the derivative along the x and y axes
 */
public static void process(ImageFloat32 orig, ImageFloat32 derivX, ImageFloat32 derivY) {
	final float[] data = orig.data;
	final float[] imgX = derivX.data;
	final float[] 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++] = (data[indexSrc + 1] - data[indexSrc - 1]) * 0.5f;
			imgY[indexY++] = (data[indexSrc + stride] - data[indexSrc - stride]) * 0.5f;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Computes derivative of ImageFloat32.  None of the images can be sub-images.
 */
public static void process_F32(ImageFloat32 orig,
							   ImageFloat32 derivX,
							   ImageFloat32 derivY) {
	final float[] data = orig.data;
	final float[] imgX = derivX.data;
	final float[] imgY = derivY.data;

	final int width = orig.getWidth();
	final int height = orig.getHeight() - 1;

	for (int y = 1; y < height; y++) {
		int endX = width * y + width - 1;

		for (int index = width * y + 1; index < endX; index++) {
			float v = (data[index + width + 1] - data[index - width - 1]) * 0.25F;
			float w = (data[index + width - 1] - data[index - width + 1]) * 0.25F;

			imgY[index] = (data[index + width] - data[index - width]) * 0.5F + v + w;
			imgX[index] = (data[index + 1] - data[index - 1]) * 0.5F + v - w;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Converts ImageSingleBand into Bitmap.
 *
 * @see #declareStorage(android.graphics.Bitmap, byte[])
 * 
 * @param input Input gray scale image.
 * @param output Output Bitmap image.
 * @param storage Byte array used for internal storage. If null it will be declared internally.
 */
public static void grayToBitmap( ImageFloat32 input , Bitmap output , byte[] storage ) {
	if( output.getWidth() != input.getWidth() || output.getHeight() != input.getHeight() ) {
		throw new IllegalArgumentException("Image shapes are not the same");
	}
	
	if( storage == null )
		storage = declareStorage(output,null);
	
	ImplConvertBitmap.grayToArray(input, storage,output.getConfig());
	output.copyPixelsFromBuffer(ByteBuffer.wrap(storage));
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static void process(ImageFloat32 orig,
						   ImageFloat32 derivX,
						   ImageFloat32 derivY) {
	final float[] data = orig.data;
	final float[] imgX = derivX.data;
	final float[] 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
			float w = data[indexSrc + strideSrc + 1] - data[indexSrc - strideSrc - 1];
			// a31 - a13
			float v = data[indexSrc + strideSrc - 1] - data[indexSrc - strideSrc + 1];

			//a32 + w + v - a12
			imgY[indexY++] = data[indexSrc + strideSrc ]+w+v-data[indexSrc - strideSrc ];

			//a23 + w - v - a21
			imgX[indexX++] = data[indexSrc + 1]+w-v-data[indexSrc - 1];
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Computes the derivative along the x and y axes
 */
public static void process(ImageFloat32 orig,
						   ImageFloat32 derivXX,
						   ImageFloat32 derivYY,
						   ImageFloat32 derivXY) {
	final float[] data = orig.data;
	final float[] imgX = derivXX.data;
	final float[] imgY = derivYY.data;
	final float[] imgXY = derivXY.data;

	final int width = orig.getWidth();
	final int height = orig.getHeight() - 2;
	final int stride = orig.stride;

	for (int y = 2; y < height; y++) {
		int indexX = derivXX.startIndex + derivXX.stride * y + 2;
		int indexY = derivYY.startIndex + derivYY.stride * y + 2;
		int indexXY = derivXY.startIndex + derivXY.stride * y + 2;

		int indexSrc = orig.startIndex + stride * y + 2;
		
		final int endX = indexSrc + width - 4;

		for (; indexSrc < endX; indexSrc++) {
			float center = 2*data[indexSrc];
			imgX[indexX++] = (data[indexSrc - 2] - center + data[indexSrc + 2]) * 0.5f;
			imgY[indexY++] = (data[indexSrc - 2*stride] - center + data[indexSrc + 2*stride]) * 0.5f;
			imgXY[indexXY++] = (data[indexSrc - stride -1] - data[indexSrc - stride + 1]
					- data[indexSrc + stride - 1] + data[indexSrc + stride + 1]) * 0.5f;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * <p>
 * Performs a single level wavelet transform.
 * </p>
 *
 * @param desc Description of the wavelet.
 * @param input Input image. Not modified.
 * @param output Where the wavelet transform is written to. Modified.
 * @param storage Optional storage image.  Should be the same size as output image. If null then
 * an image is declared internally.
 */
public static void transform1( WaveletDescription<WlCoef_F32> desc ,
							   ImageFloat32 input , ImageFloat32 output ,
							   ImageFloat32 storage )
{
	UtilWavelet.checkShape(input,output);

	WlCoef_F32 coef = desc.getForward();

	if( output.width < coef.scaling.length || output.width < coef.wavelet.length )
		throw new IllegalArgumentException("Wavelet is too large for provided image.");
	if( output.height < coef.scaling.length || output.height < coef.wavelet.length )
		throw new IllegalArgumentException("Wavelet is too large for provided image.");
	storage = InputSanityCheck.checkDeclare(output, storage);

	// the faster routines can only be run on images which are not too small
	int minSize = Math.max(coef.getScalingLength(),coef.getWaveletLength())*3;

	if( input.getWidth() <= minSize || input.getHeight() <= minSize ) {
		ImplWaveletTransformNaive.horizontal(desc.getBorder(),coef,input,storage);
		ImplWaveletTransformNaive.vertical(desc.getBorder(),coef,storage,output);
	} else {
		ImplWaveletTransformInner.horizontal(coef,input,storage);
		ImplWaveletTransformBorder.horizontal(desc.getBorder(),coef,input,storage);
		ImplWaveletTransformInner.vertical(coef,storage,output);
		ImplWaveletTransformBorder.vertical(desc.getBorder(),coef,storage,output);
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * <p>
 * Performs a single level inverse wavelet transform. Do not pass in a whole image which has been
 * transformed by a multilevel transform.  Just the relevant sub-image.
 * </p>
 *
 * @param desc Description of the inverse wavelet.
 * @param input Input wavelet transform. Not modified.
 * @param output Reconstruction of original image. Modified.
 * @param storage Optional storage image.  Should be the same size as the input image. If null then
 * an image is declared internally.
 * @param minValue Minimum allowed pixel value
 * @param maxValue Maximum allowed pixel value
 */
public static void inverse1( WaveletDescription<WlCoef_F32> desc ,
							 ImageFloat32 input , ImageFloat32 output ,
							 ImageFloat32 storage , float minValue , float maxValue )
{
	UtilWavelet.checkShape(output,input);
	WlCoef_F32 coef = desc.getForward();
	if( output.width < coef.scaling.length || output.width < coef.wavelet.length )
		throw new IllegalArgumentException("Wavelet is too large for provided image.");
	if( output.height < coef.scaling.length || output.height < coef.wavelet.length )
		throw new IllegalArgumentException("Wavelet is too large for provided image.");
	storage = InputSanityCheck.checkDeclare(input, storage);

	// the faster routines can only be run on images which are not too small
	int minSize = Math.max(coef.getScalingLength(),coef.getWaveletLength())*3;

	if( output.getWidth() <= minSize || output.getHeight() <= minSize ) {
		ImplWaveletTransformNaive.verticalInverse(desc.getBorder(), desc.getInverse(), input, storage);
		ImplWaveletTransformNaive.horizontalInverse(desc.getBorder(), desc.getInverse(), storage, output);
	} else {
		ImplWaveletTransformInner.verticalInverse(desc.getInverse().getInnerCoefficients(),input,storage);
		ImplWaveletTransformBorder.verticalInverse(desc.getBorder(),desc.getInverse(),input,storage);
		ImplWaveletTransformInner.horizontalInverse(desc.getInverse().getInnerCoefficients(),storage,output);
		ImplWaveletTransformBorder.horizontalInverse(desc.getBorder(),desc.getInverse(),storage,output);
	}
	if( minValue != -Float.MAX_VALUE && maxValue != Float.MAX_VALUE )
		PixelMath.boundImage(output,minValue,maxValue);
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static void horizontal5( Kernel1D_F32 kernel ,
								ImageFloat32 image, ImageFloat32 dest,
								boolean includeBorder) {
	final float[] dataSrc = image.data;
	final float[] dataDst = dest.data;

	final float k1 = kernel.data[0];
	final float k2 = kernel.data[1];
	final float k3 = kernel.data[2];
	final float k4 = kernel.data[3];
	final float k5 = kernel.data[4];

	final int radius = kernel.getRadius();

	final int yBorder = includeBorder ? 0 : radius;

	final int width = image.getWidth();
	final int height = image.getHeight()-yBorder;

	for( int i = yBorder; i < 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;
			float total = (dataSrc[indexSrc++])*k1;
			total += (dataSrc[indexSrc++])*k2;
			total += (dataSrc[indexSrc++])*k3;
			total += (dataSrc[indexSrc++])*k4;
			total += (dataSrc[indexSrc])*k5;

			dataDst[indexDst++] = total;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Can only be used with images that are NOT sub-images.
 */
public static void derivX_F32(ImageFloat32 orig,
							  ImageFloat32 derivX) {
	final float[] data = orig.data;
	final float[] imgX = derivX.data;

	final int width = orig.getWidth();
	final int height = orig.getHeight();

	for (int y = 0; y < height; y++) {
		int index = width * y + 1;
		int endX = index + width - 2;
		int endXAlt = endX - (width - 2) % 3;

		float x0 = data[index - 1];
		float x1 = data[index];

		for (; index < endXAlt;) {
			float x2 = data[index + 1];
			imgX[index++] = (x2 - x0) * 0.5f;
			x0 = data[index + 1];
			imgX[index++] = (x0 - x1) * 0.5f;
			x1 = data[index + 1];
			imgX[index++] = (x1 - x2) * 0.5f;
		}

		for (; index < endX; index++) {
			imgX[index] = (data[index + 1] - data[index - 1]) * 0.5f;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
private void strictRule(ImageFloat32 intensityImage, QueueCorner corners) {
	final int imgWidth = intensityImage.getWidth();
	final int imgHeight = intensityImage.getHeight();

	final float inten[] = intensityImage.data;

	for (int y = border; y < imgHeight - border; y++) {
		int center = intensityImage.startIndex + y * intensityImage.stride + border;
		for (int x = border; x < imgWidth - border; x++) {

			float val = inten[center++];
			if (val < thresh) continue;

			boolean max = true;

			int x0 = x - radius;
			int x1 = x + radius;
			int y0 = y - radius;
			int y1 = y + radius;

			if (x0 < border) x0 = border;
			if (y0 < border) y0 = border;
			if (x1 >= imgWidth-border) x1 = imgWidth - border - 1;
			if (y1 >= imgHeight-border) y1 = imgHeight - border - 1;

			escape:
			for (int i = y0; i <= y1; i++) {
				int index = intensityImage.startIndex + i * intensityImage.stride + x0;
				for (int j = x0; j <= x1; j++, index++) {
					// don't compare the center point against itself
					if (i == y && j == x)
						continue;

					if (val <= inten[index]) {
						max = false;
						break escape;
					}
				}
			}

			// add points which are local maximums and are not already contained in the corners list
			if (max && val != Float.MAX_VALUE) {
				corners.add(x, y);
			}
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static void vertical9( Kernel1D_F32 kernel,
							 ImageFloat32 image, ImageFloat32 dest,
							 boolean includeBorder)
{
	final float[] dataSrc = image.data;
	final float[] dataDst = dest.data;

	final float k1 = kernel.data[0];
	final float k2 = kernel.data[1];
	final float k3 = kernel.data[2];
	final float k4 = kernel.data[3];
	final float k5 = kernel.data[4];
	final float k6 = kernel.data[5];
	final float k7 = kernel.data[6];
	final float k8 = kernel.data[7];
	final float k9 = kernel.data[8];

	final int radius = kernel.getRadius();

	final int imgWidth = dest.getWidth();
	final int imgHeight = dest.getHeight();

	final int yEnd = imgHeight-radius;

	final int xBorder = includeBorder ? 0 : radius;

	for( int y = radius; y < yEnd; y++ ) {
		int indexDst = dest.startIndex+y*dest.stride+xBorder;
		int i = image.startIndex + (y-radius)*image.stride;
		final int iEnd = i+imgWidth-xBorder;

		for( i += xBorder; i < iEnd; i++ ) {
			int indexSrc = i;

			float total = (dataSrc[indexSrc]) * k1;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k2;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k3;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k4;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k5;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k6;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k7;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k8;
			indexSrc += image.stride;
			total += (dataSrc[indexSrc])*k9;

			dataDst[indexDst++] = total;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static void horizontal7( Kernel1D_F32 kernel ,
								ImageFloat32 input, ImageFloat32 output ,
								int skip ) {
	final float[] dataSrc = input.data;
	final float[] dataDst = output.data;

	final float k1 = kernel.data[0];
	final float k2 = kernel.data[1];
	final float k3 = kernel.data[2];
	final float k4 = kernel.data[3];
	final float k5 = kernel.data[4];
	final float k6 = kernel.data[5];
	final float k7 = kernel.data[6];

	final int radius = kernel.getRadius();

	final int widthEnd = UtilDownConvolve.computeMaxSide(input.width,skip,radius);
	final int height = input.getHeight();

	final int offsetX = UtilDownConvolve.computeOffset(skip,radius);

	for( int i = 0; i < height; i++ ) {
		int indexDst = output.startIndex + i*output.stride + offsetX/skip;
		int j = input.startIndex + i*input.stride - radius;
		final int jEnd = j+widthEnd;

		for( j += offsetX; j <= jEnd; j += skip ) {
			int indexSrc = j;

			float total = (dataSrc[indexSrc++] ) * k1;
			total += (dataSrc[indexSrc++])*k2;
			total += (dataSrc[indexSrc++])*k3;
			total += (dataSrc[indexSrc++])*k4;
			total += (dataSrc[indexSrc++])*k5;
			total += (dataSrc[indexSrc++])*k6;
			total += (dataSrc[indexSrc])*k7;

			dataDst[indexDst++] = total;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static void horizontal9( Kernel1D_F32 kernel ,
								ImageFloat32 input, ImageFloat32 output ,
								int skip ) {
	final float[] dataSrc = input.data;
	final float[] dataDst = output.data;

	final float k1 = kernel.data[0];
	final float k2 = kernel.data[1];
	final float k3 = kernel.data[2];
	final float k4 = kernel.data[3];
	final float k5 = kernel.data[4];
	final float k6 = kernel.data[5];
	final float k7 = kernel.data[6];
	final float k8 = kernel.data[7];
	final float k9 = kernel.data[8];

	final int radius = kernel.getRadius();

	final int widthEnd = UtilDownConvolve.computeMaxSide(input.width,skip,radius);
	final int height = input.getHeight();

	final int offsetX = UtilDownConvolve.computeOffset(skip,radius);

	for( int i = 0; i < height; i++ ) {
		int indexDst = output.startIndex + i*output.stride + offsetX/skip;
		int j = input.startIndex + i*input.stride - radius;
		final int jEnd = j+widthEnd;

		for( j += offsetX; j <= jEnd; j += skip ) {
			int indexSrc = j;

			float total = (dataSrc[indexSrc++] ) * k1;
			total += (dataSrc[indexSrc++])*k2;
			total += (dataSrc[indexSrc++])*k3;
			total += (dataSrc[indexSrc++])*k4;
			total += (dataSrc[indexSrc++])*k5;
			total += (dataSrc[indexSrc++])*k6;
			total += (dataSrc[indexSrc++])*k7;
			total += (dataSrc[indexSrc++])*k8;
			total += (dataSrc[indexSrc])*k9;

			dataDst[indexDst++] = total;
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
public static void horizontal11( Kernel1D_F32 kernel ,
								ImageFloat32 input, ImageFloat32 output ,
								int skip ) {
	final float[] dataSrc = input.data;
	final float[] dataDst = output.data;

	final float k1 = kernel.data[0];
	final float k2 = kernel.data[1];
	final float k3 = kernel.data[2];
	final float k4 = kernel.data[3];
	final float k5 = kernel.data[4];
	final float k6 = kernel.data[5];
	final float k7 = kernel.data[6];
	final float k8 = kernel.data[7];
	final float k9 = kernel.data[8];
	final float k10 = kernel.data[9];
	final float k11 = kernel.data[10];

	final int radius = kernel.getRadius();

	final int widthEnd = UtilDownConvolve.computeMaxSide(input.width,skip,radius);
	final int height = input.getHeight();

	final int offsetX = UtilDownConvolve.computeOffset(skip,radius);

	for( int i = 0; i < height; i++ ) {
		int indexDst = output.startIndex + i*output.stride + offsetX/skip;
		int j = input.startIndex + i*input.stride - radius;
		final int jEnd = j+widthEnd;

		for( j += offsetX; j <= jEnd; j += skip ) {
			int indexSrc = j;

			float total = (dataSrc[indexSrc++] ) * k1;
			total += (dataSrc[indexSrc++])*k2;
			total += (dataSrc[indexSrc++])*k3;
			total += (dataSrc[indexSrc++])*k4;
			total += (dataSrc[indexSrc++])*k5;
			total += (dataSrc[indexSrc++])*k6;
			total += (dataSrc[indexSrc++])*k7;
			total += (dataSrc[indexSrc++])*k8;
			total += (dataSrc[indexSrc++])*k9;
			total += (dataSrc[indexSrc++])*k10;
			total += (dataSrc[indexSrc])*k11;

			dataDst[indexDst++] = total;
		}
	}
}