import net.imglib2.RealLocalizable; //导入依赖的package包/类
protected void paint( final RealLocalizable coords)
{
	final AccessBoxRandomAccessible< LongType > accessBoxExtendedLabels = new AccessBoxRandomAccessible<>( extendedLabels );
	final RandomAccessible< LongType > labelSource = Views.hyperSlice( accessBoxExtendedLabels, brushNormalAxis, Math.round( coords.getDoublePosition( 2 ) ) );

	final Neighborhood< LongType > sphere =
			HyperSphereNeighborhood.< LongType >factory().create(
					new long[]{
							Math.round( coords.getDoublePosition( brushNormalAxis == 0 ? 1 : 0 ) ),
							Math.round( coords.getDoublePosition( brushNormalAxis == 2 ? 1 : 2 ) ) },
					Math.round( brushRadius / Affine3DHelpers.extractScale( labelTransform, brushNormalAxis == 0 ? 1 : 0 ) ),
					labelSource.randomAccess() );

	for ( final LongType t : sphere )
		t.set( getValue() );

	dirtyLabelsInterval.touch( accessBoxExtendedLabels.createAccessInterval() );
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public void applyInverse( final RealPositionable source, final RealLocalizable target )
{
	if( tps == null )
	{
		for ( int d = 0; d < target.numDimensions(); ++d )
			source.setPosition( target.getDoublePosition( d ), d );
			
		return;
	}
	
	double[] pt = new double[ tps.getNumDims() ];
	for ( int d = 0; d < tps.getNumDims(); ++d )
		pt[ d ] = target.getDoublePosition( d );
	
	double[] ptxfm = tps.apply( pt );
	
	for ( int d = 0; d < tps.getNumDims(); ++d )
		source.setPosition( ptxfm[ d ], d);
	
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
public int getIndexNearestTo( RealLocalizable pt, boolean isMoving )
{
	Double[] p;
	double minDist = Double.MAX_VALUE;
	int minIndex = -1;
	for( int i = 0; i < numRows; i++ )
	{
		p = getPoint( isMoving, i );
		double thisdist = squaredDistance( p, pt );
		if( thisdist < minDist )
		{
			minDist = thisdist;
			minIndex = i;
		}
	}
	return minIndex;
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public void updateFigure(final OverlayView view, final BezierFigure figure) {
	super.updateFigure(view, figure);
	final PolygonOverlay polygonOverlay = downcastOverlay(view.getData());
	final PolygonRegionOfInterest roi = polygonOverlay.getRegionOfInterest();
	final int vertexCount = roi.getVertexCount();
	while (figure.getNodeCount() > vertexCount) {
		figure.removeNode(vertexCount);
	}
	for (int i = 0; i < vertexCount; i++) {
		final RealLocalizable vertex = roi.getVertex(i);
		final double x = vertex.getDoublePosition(0);
		final double y = vertex.getDoublePosition(1);
		if (figure.getNodeCount() == i) {
			figure.addNode(new Node(x, y));
		}
		else {
			final Node node = figure.getNode(i);
			node.mask = 0;
			Arrays.fill(node.x, x);
			Arrays.fill(node.y, y);
		}
	}
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public RealLocalizable calculate(final IterableInterval<T> input) {
	final int numDimensions = input.numDimensions();

	final double[] output = new double[numDimensions];
	final double[] intensityValues = new double[numDimensions];

	final Cursor<T> c = input.localizingCursor();
	while (c.hasNext()) {
		c.fwd();
		for (int i = 0; i < output.length; i++) {
			output[i] += c.getDoublePosition(i) * c.get().getRealDouble();
			intensityValues[i] += c.get().getRealDouble();
		}
	}

	for (int i = 0; i < output.length; i++) {
		output[i] = output[i] / intensityValues[i];
	}

	return new RealPoint(output);
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public void compute(final Polygon input, final DoubleType output) {
	final List<? extends RealLocalizable> minBB = minimumBoundingBoxFunc.calculate(input).getVertices();

	final RealLocalizable p1 = minBB.get(0);
	final RealLocalizable p2 = minBB.get(1);
	final RealLocalizable p3 = minBB.get(2);

	double width = Math.sqrt(Math.pow(p1.getDoublePosition(0) - p2.getDoublePosition(0), 2)
			+ Math.pow(p1.getDoublePosition(1) - p2.getDoublePosition(1), 2));
	double length = Math.sqrt(Math.pow(p2.getDoublePosition(0) - p3.getDoublePosition(0), 2)
			+ Math.pow(p2.getDoublePosition(1) - p3.getDoublePosition(1), 2));

	if (width > length) {
		final double tmp = width;
		width = length;
		length = tmp;
	}
	output.set(1d - (width / length));
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public Pair<RealLocalizable, RealLocalizable> calculate(Polygon input) {
	final List<? extends RealLocalizable> points = function.calculate(input).getVertices();

	double distance = Double.NEGATIVE_INFINITY;
	RealLocalizable p0 = points.get(0);
	RealLocalizable p1 = points.get(0);
	for (int i = 0; i < points.size(); i++) {
		for (int j = i + 2; j < points.size(); j++) {
			final RealLocalizable tmpP0 = points.get(i);
			final RealLocalizable tmpP1 = points.get(j);

			final double tmp = Math.sqrt(Math.pow(tmpP0.getDoublePosition(0) - tmpP1.getDoublePosition(0), 2)
					+ Math.pow(tmpP0.getDoublePosition(1) - tmpP1.getDoublePosition(1), 2));

			if (tmp > distance) {
				distance = tmp;
				p0 = tmpP0;
				p1 = tmpP1;
			}
		}
	}
	
	return new ValuePair<>(p0, p1);
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public void compute(Polygon input, DoubleType output) {
	final List<? extends RealLocalizable> points = function.calculate(input).getVertices();

	final double angleRad = -angle * Math.PI / 180.0;
	
	double minX = Double.POSITIVE_INFINITY;
	double maxX = Double.NEGATIVE_INFINITY;
	
	for (RealLocalizable p : points) {
		final double tmpX = p.getDoublePosition(0) * Math.cos(angleRad) - p.getDoublePosition(1) * Math.sin(angleRad);
		minX = tmpX < minX ? tmpX : minX;
		maxX = tmpX > maxX ? tmpX : maxX;
	}
	
	output.set(Math.abs(maxX - minX));
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
/**
 * Rotates the given Polygon consisting of a list of RealPoints by the given
 * angle about the given center.
 *
 * @param inPoly A Polygon consisting of a list of RealPoint RealPoints
 * @param angle the rotation angle
 * @param center the rotation center
 * @return a rotated polygon
 */
private Polygon rotate(final Polygon inPoly, final double angle,
	final RealLocalizable center)
{

	List<RealLocalizable> out = new ArrayList<>();

	for (RealLocalizable RealPoint : inPoly.getVertices()) {

		// double angleInRadians = Math.toRadians(angleInDegrees);
		double cosTheta = Math.cos(angle);
		double sinTheta = Math.sin(angle);

		double x = cosTheta * (RealPoint.getDoublePosition(0) - center
			.getDoublePosition(0)) - sinTheta * (RealPoint.getDoublePosition(1) -
				center.getDoublePosition(1)) + center.getDoublePosition(0);

		double y = sinTheta * (RealPoint.getDoublePosition(0) - center
			.getDoublePosition(0)) + cosTheta * (RealPoint.getDoublePosition(1) -
				center.getDoublePosition(1)) + center.getDoublePosition(1);

		out.add(new RealPoint(x, y));
	}

	return new Polygon(out);
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public void compute(final Polygon input, final DoubleType output) {
	double perimeter = 0;
	final List<? extends RealLocalizable> vertices = input.getVertices();
	final int size = vertices.size();
	for (int i = 0; i < size; i++) {
		final int nexti = (i + 1) % size;

		final double dx2 = vertices.get(nexti).getDoublePosition(0) - vertices.get(i).getDoublePosition(0);
		final double dy2 = vertices.get(nexti).getDoublePosition(1) - vertices.get(i).getDoublePosition(1);

		perimeter += Math.sqrt(dx2 * dx2 + dy2 * dy2);
	}

	output.set(perimeter);
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public void compute(Polygon input, DoubleType output) {
	double sum = 0;
	final int numVertices = input.getVertices().size();
	for (int i = 0; i < numVertices; i++) {

		final RealLocalizable p0 = input.getVertices().get(i);
		final RealLocalizable p1 = input.getVertices().get((i + 1) % numVertices);

		final double p0_x = p0.getDoublePosition(0);
		final double p0_y = p0.getDoublePosition(1);
		final double p1_x = p1.getDoublePosition(0);
		final double p1_y = p1.getDoublePosition(1);

		sum += p0_x * p1_y - p0_y * p1_x;
	}
	output.set(Math.abs(sum) / 2d);
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public RealLocalizable calculate(final IterableInterval<?> input) {
	int numDimensions = input.numDimensions();
	double[] output = new double[numDimensions];
	Cursor<?> c = input.localizingCursor();
	double[] pos = new double[numDimensions];
	while (c.hasNext()) {
		c.fwd();
		c.localize(pos);
		for (int i = 0; i < output.length; i++) {
			output[i] += pos[i];
		}
	}

	for (int i = 0; i < output.length; i++) {
		output[i] = output[i] / input.size();
	}

	return new RealPoint(output);
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public Mesh calculate(final Mesh input) {
	DefaultMesh output = new DefaultMesh();
	Set<Vertex> vertices = new LinkedHashSet<>();
	for (final RealLocalizable v : input.getVertices()) {
		vertices.add(new Vertex(v.getDoublePosition(0), v.getDoublePosition(1), v
			.getDoublePosition(2)));
	}
	List<TriangularFacet> facets = new ArrayList<>();
	List<TriangularFacet> facetsWithPointInFront = new ArrayList<>();
	final double epsilon = computeHull(vertices, facets,
		facetsWithPointInFront);
	for (TriangularFacet f : facets) {
		output.addFace(f);
	}
	output.setEpsilon(epsilon);
	return output;
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public RealLocalizable calculate(final Polygon input) {

	double area = sizeFunc.calculate(input).get();
	double cx = 0;
	double cy = 0;
	for (int i = 0; i < input.getVertices().size(); i++) {
		RealLocalizable p0 = input.getVertices().get(i);
		RealLocalizable p1 = input.getVertices().get((i + 1) % input.getVertices()
				.size());

		double p0_x = p0.getDoublePosition(0);
		double p0_y = p0.getDoublePosition(1);
		double p1_x = p1.getDoublePosition(0);
		double p1_y = p1.getDoublePosition(1);

		cx += (p0_x + p1_x) * (p0_x * p1_y - p1_x * p0_y);
		cy += (p0_y + p1_y) * (p0_x * p1_y - p1_x * p0_y);
	}

	return new RealPoint(cx / (area * 6), cy / (area * 6));
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Test
public void quickhull_6_Test() {
	LinkedHashSet<RealLocalizable> points = new LinkedHashSet<>();
	points.add(new Vertex(3.2, 4.8, 4.4));
	points.add(new Vertex(0, -4.9, 1.1));
	points.add(new Vertex(-2.4, 4.9, -3.1));
	points.add(new Vertex(4.5, -0.9, -2.5));
	points.add(new Vertex(-4.7, 0.4, -4.2));
	points.add(new Vertex(-1.9, 2.2, -3.3));

	DefaultMesh df = new DefaultMesh(points);

	DefaultMesh convexHull = (DefaultMesh) ops.run(DefaultConvexHull3D.class, df);
	assertTrue(isConvex(convexHull.getFacets(), convexHull.getEpsilon()));
	assertEquals(5, convexHull.getVertices().size());
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Test
public void convexHull2D() {
	// ground truth computed with matlab
	final Polygon test = (Polygon) ops.run(DefaultConvexHull2D.class, contour);
	final List<? extends RealLocalizable> received = test.getVertices();
	final RealPoint[] expected = new RealPoint[] { new RealPoint(1, 30), new RealPoint(2, 29), new RealPoint(26, 6),
			new RealPoint(31, 6), new RealPoint(42, 9), new RealPoint(49, 22), new RealPoint(72, 65),
			new RealPoint(78, 77), new RealPoint(48, 106), new RealPoint(42, 109), new RealPoint(34, 109),
			new RealPoint(28, 106), new RealPoint(26, 104), new RealPoint(23, 98) };
	assertEquals("Number of polygon points differs.", expected.length, received.size());
	for (int i = 0; i < expected.length; i++) {
		assertEquals("Polygon point " + i + " differs in x-coordinate.", expected[i].getDoublePosition(0),
				received.get(i).getDoublePosition(0), EPSILON);
		assertEquals("Polygon point " + i + " differs in y-coordinate.", expected[i].getDoublePosition(1),
				received.get(i).getDoublePosition(1), EPSILON);
	}
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Test
public void smallesEnclosingRectangle() {
	// ground truth verified with matlab
	final List<? extends RealLocalizable> received = ((Polygon) ops.run(DefaultSmallestEnclosingRectangle.class,
			contour)).getVertices();
	final RealPoint[] expected = new RealPoint[] { new RealPoint(37.229184188393, -0.006307821699),
			new RealPoint(-14.757779646762, 27.800672834315), new RealPoint(31.725820016821, 114.704793944491),
			new RealPoint(83.712783851976, 86.897813288478) };
	assertEquals("Number of polygon points differs.", expected.length, received.size());
	for (int i = 0; i < expected.length; i++) {
		assertEquals("Polygon point " + i + " differs in x-coordinate.", expected[i].getDoublePosition(0),
				received.get(i).getDoublePosition(0), EPSILON);
		assertEquals("Polygon point " + i + " differs in y-coordinate.", expected[i].getDoublePosition(1),
				received.get(i).getDoublePosition(1), EPSILON);
	}
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Test
public void labelRegionToPolygonConverter() {
	// ground truth computed with matlab
	final LabelRegionToPolygonConverter c = new LabelRegionToPolygonConverter();
	c.setContext(ops.context());
	final Polygon test = c.convert(ROI, Polygon.class);
	final List<? extends RealLocalizable> expected = contour.getVertices();
	final List<? extends RealLocalizable> received = test.getVertices();
	assertEquals("Number of polygon points differs.", expected.size(), received.size());
	for (int i = 0; i < contour.getVertices().size(); i++) {
		assertEquals("Polygon point " + i + " differs in x-coordinate.", expected.get(i).getDoublePosition(0),
				received.get(i).getDoublePosition(0), EPSILON);
		assertEquals("Polygon point " + i + " differs in y-coordinate.", expected.get(i).getDoublePosition(1),
				received.get(i).getDoublePosition(1), EPSILON);
	}
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public double partial( final RealLocalizable pos, final int d, final int param )
{
	final int i = param / ( n + 1 );
	if ( i != d )
		return 0.0;
	final int j = param - i * ( n + 1 );
	return j == n ? 1.0 : pos.getDoublePosition( j );
}
 

import net.imglib2.RealLocalizable; //导入依赖的package包/类
@Override
public double partial(RealLocalizable pos, int d, int param)
{
	// we evaluate at p1,...,p3 = (1,0,0,0) (identity as quat)

	// translational part of Jacobian = I
	if ( param > 3 )
		return ( param - 4 ) == d ? 1.0 : 0.0;

	final int c = lut[d][param];

	// set Quat derivatives according to LUT above (*2)
	return c == 0 ? 0 : ( c < 0 ? -2 * pos.getDoublePosition( -c - 1 ) : 2 * pos.getDoublePosition( c - 1 ) );
}