Java Point类代码示例

import net.imglib2.Point; //导入依赖的package包/类
/**
 * Calculates the index of a point in a buffer of a Tensor of the given
 * shape
 */
private int calcIndex(final long[] shape, final int[] mapping, final Point p) {
	assert p.numDimensions() == shape.length;
	int n = shape.length;

	// switch index and value of the mapping
	int[] switchedMapping = new int[mapping.length];
	IntStream.range(0, mapping.length).forEach(i -> switchedMapping[mapping[i]] = i);

	int index = 0;
	for (int dimPreSize = 1, d = n - 1; d >= 0; d--) {
		index += dimPreSize * p.getIntPosition(switchedMapping[d]);
		dimPreSize *= shape[d];
	}
	return index;
}
 

import net.imglib2.Point; //导入依赖的package包/类
public static void main(String[] args) {
	
	double o1 = 6;
	double o2 = Double.NEGATIVE_INFINITY;
	int np1 = 30;
	int np2 = 20;

	System.out.println( Double.isInfinite( o2 ));

	int ccCompare = Double.compare(o1, o2);
	if (ccCompare != 0)
		System.out.println( ccCompare );
	else 
		System.out.println( (int)(np1 - np2) );
	
	System.exit( 0 );
	PhaseCorrelationPeak2 peaks = new PhaseCorrelationPeak2(new Point(new int[] {10, 10}), 1.0);
	Dimensions pcmDims = new FinalDimensions(new int[] {50, 50});
	Dimensions imgDims = new FinalDimensions(new int[] {30, 30});
	PhaseCorrelation2Util.expandPeakToPossibleShifts(peaks, pcmDims, imgDims, imgDims);
	
}
 

import net.imglib2.Point; //导入依赖的package包/类
@Override
public void click( final int x, final int y )
{
	if ( filledPixelsOverlay.visible() )
	{
		synchronized ( viewer )
		{
			viewer.setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR ) );

			final Point p = new Point( x, y );

			final ArrayImg< ByteType, ByteArray > img = wrapBufferedImage( filledPixelsOverlay.img );

			final ByteType extension = new ByteType( ( byte ) 1 );

			final long t0 = System.currentTimeMillis();
			final ArrayRandomAccess< ByteType > ra = img.randomAccess();
			ra.setPosition( p );
			FloodFill.fill( Views.extendValue( img, extension ), Views.extendValue( img, extension ), p, extension.copy(), extension.copy(), new DiamondShape( 1 ), filter );
			final long t1 = System.currentTimeMillis();
			System.out.println( "Filling took " + ( t1 - t0 ) + " ms" );
			viewer.setCursor( Cursor.getPredefinedCursor( Cursor.DEFAULT_CURSOR ) );
			viewer.getDisplay().repaint();
		}
	}
}
 

import net.imglib2.Point; //导入依赖的package包/类
public void testCorners() {
	long[] window = new long[]{10, 10, 10};
	int numDimensions = window.length;
	Point[] offsets = new Point[(int)Math.pow(2, numDimensions)];
	for (int i=0; i<offsets.length; ++i) offsets[i] = new Point(numDimensions);
	int d = 0;
	while (d < numDimensions) {
		final int flip = (int)Math.pow(2, d);
		int sign = -1;
		for (int i=0; i<offsets.length;) {
			offsets[i].setPosition(sign * window[d] / 2, d);
			++i;
			if (0 == i % flip) sign *= -1;
		}
		++d;
	}
	for (int i=0; i<offsets.length; ++i) {
		System.out.println(offsets[i].toString());
	}
}
 

import net.imglib2.Point; //导入依赖的package包/类
@SuppressWarnings( "unchecked" )
static ArrayList< Point >[] getInsidePoints( final ArrayList< Point > points, final double[][] planes )
{
	final int nPlanes = planes.length;
	final int n = points.get( 0 ).numDimensions();
	final ArrayList< Point > inside = new ArrayList< Point >();
	final ArrayList< Point > outside = new ArrayList< Point >();
	A: for ( final Point p : points )
	{
		for ( int i = 0; i < nPlanes; ++i )
		{
			final double[] plane = planes[ i ];
			double dot = 0;
			for ( int d = 0; d < n; ++d )
				dot += p.getDoublePosition( d ) * plane[ d ];
			if ( dot < plane[ n ] )
			{
				outside.add( p );
				continue A;
			}
		}
		inside.add( p );
	}
	return new ArrayList[] { inside, outside };
}
 

import net.imglib2.Point; //导入依赖的package包/类
/**
 * Gaussian Smooth of the input image using intermediate float format.
 * @param <T>
 * @param img
 * @param sigma
 * @return
 */
public static <T extends RealType<T> & NativeType<T>> RandomAccessibleInterval<T> gaussianSmooth(
		RandomAccessibleInterval<T> img, double[] sigma) {
	Interval interval = Views.iterable(img);

	ImgFactory<T> outputFactory = new ArrayImgFactory<T>();
	final long[] dim = new long[ img.numDimensions() ];
	img.dimensions(dim);
	RandomAccessibleInterval<T> output = outputFactory.create( dim,
			img.randomAccess().get().createVariable() );

	final long[] pos = new long[ img.numDimensions() ];
	Arrays.fill(pos, 0);
	Localizable origin = new Point(pos);

	ImgFactory<FloatType> tempFactory = new ArrayImgFactory<FloatType>();
	RandomAccessible<T> input = Views.extendMirrorSingle(img);
	Gauss.inFloat(sigma, input, interval, output, origin, tempFactory);

	return output;
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Checks one image for the dimensions and marked points */
private <T extends RealType<T>> void checkImage(final Img<T> img, final int n, final long[] dims,
		final List<Point> points) {
	assertArrayEquals(dims, Intervals.dimensionsAsLongArray(img));
	assertEquals(n, img.numDimensions());
	checkPoints(img, points);
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Tests the tensor(RAI) function for one image */
private <T extends RealType<T>> void testImg2TensorReverseForType(final Img<T> img, final int n, final long[] shape,
		final DataType t) {
	// Put some values to check into the image
	List<Point> points = createTestPoints(n);
	markPoints(img, points);

	Tensor tensor = Tensors.tensor(img);

	assertArrayEquals(shape, tensor.shape());
	assertEquals(n, tensor.numDimensions());
	assertEquals(t, tensor.dataType());
	checkPointsTensor(tensor, IntStream.range(0, n).map(i -> n - 1 - i).toArray(), points);
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Tests the tensorDirect(RAI) function for one image */
private <T extends RealType<T>> void testImg2TensorDirectForType(final Img<T> img, final int n, final long[] shape,
		final DataType t) {
	// Put some values to check into the image
	List<Point> points = createTestPoints(n);
	markPoints(img, points);

	Tensor tensor = Tensors.tensorDirect(img);

	assertArrayEquals(shape, tensor.shape());
	assertEquals(n, tensor.numDimensions());
	assertEquals(t, tensor.dataType());
	checkPointsTensor(tensor, IntStream.range(0, n).toArray(), points);
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Tests the tensor(RAI, int[]) function for one image */
private <T extends RealType<T>> void testImg2TensorMappingForType(final Img<T> img, final int[] mapping,
		final int n, final long[] shape, final DataType t) {
	// Put some values to check into the image
	List<Point> points = createTestPoints(n);
	markPoints(img, points);
	Tensor tensor = Tensors.tensor(img, mapping);

	assertArrayEquals(shape, tensor.shape());
	assertEquals(n, tensor.numDimensions());
	assertEquals(t, tensor.dataType());
	checkPointsTensor(tensor, mapping, points);
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Creates some interesting points to mark */
private List<Point> createTestPoints(int n) {
	List<Point> points = new ArrayList<>();
	points.add(new Point(n));
	for (int d = 0; d < n; d++) {
		Point p = new Point(n);
		p.fwd(d);
		points.add(p);
	}
	return points;
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Marks a list of points in an image */
private <T extends RealType<T>> void markPoints(final Img<T> img, final List<Point> points) {
	for (int i = 0; i < points.size(); i++) {
		RandomAccess<T> randomAccess = img.randomAccess();
		randomAccess.setPosition(points.get(i));
		randomAccess.get().setReal(i + 1);
	}
}
 

import net.imglib2.Point; //导入依赖的package包/类
/** Checks if points in an image are set to the right value */
private <T extends RealType<T>> void checkPoints(final Img<T> img, List<Point> points) {
	for (int i = 0; i < points.size(); i++) {
		RandomAccess<T> randomAccess = img.randomAccess();
		randomAccess.setPosition(points.get(i));
		assertEquals(i + 1, randomAccess.get().getRealFloat(), 0.001);
	}
}
 

import net.imglib2.Point; //导入依赖的package包/类
/**
 * Calculates the index of a point in a Tensor buffer and executes the
 * BiConsumer with the index and the value of the point (which is the index
 * in the list + 1).
 */
private void execForPointsWithBufferIndex(final long[] shape, final int[] mapping, final List<Point> points,
		final BiConsumer<Integer, Integer> exec) {
	for (int i = 0; i < points.size(); i++) {
		exec.accept(calcIndex(shape, mapping, points.get(i)), i + 1);
	}
}
 

import net.imglib2.Point; //导入依赖的package包/类
public static void main(String[] args)
{
	RigidWarp3D warp = new RigidWarp3D();
	AffineGet affine = warp
			.getAffine( new double[] { Math.cos( Math.PI / 4 ) - 1, 0, 0, Math.sin( Math.PI / 4 ), 2, 2, 2 } );
	System.out.println( Util.printCoordinates( affine.getRowPackedCopy() ) );

	for ( int d = 0; d < 3; d++ )
		for ( int p = 0; p < warp.numParameters(); p++ )
			System.out.println( warp.partial( new Point( 1, 2, 3 ), d, p ) );
}