Java Point2d.translate方法代码示例

import org.openimaj.math.geometry.point.Point2d; //导入方法依赖的package包/类
/**
 * Apply the radial and tangential distortion of this camera to the given
 * projected point (presumably computed by projecting a world point through
 * the homography defined by the extrinsic parameters of a camera). The
 * point is modified in-place.
 * 
 * @param p
 *            the projected point
 * @return the input point (with the distortion added)
 */
public Point2d applyDistortion(Point2d p) {
	final double dx = (p.getX() - getPrincipalPointX()) / getFocalLengthX();
	final double dy = (p.getY() - getPrincipalPointY()) / getFocalLengthY();
	final double r2 = dx * dx + dy * dy;
	final double r4 = r2 * r2;
	final double r6 = r2 * r2 * r2;

	// radial component
	double tx = dx * (k1 * r2 + k2 * r4 + k3 * r6);
	double ty = dy * (k1 * r2 + k2 * r4 + k3 * r6);

	// tangential component
	tx += 2 * p1 * dx * dy + p2 * (r2 + 2 * dx * dx);
	ty += p1 * (r2 + 2 * dy * dy) + 2 * p2 * dx * dy;

	p.translate((float) tx, (float) ty);
	return p;
}
 

import org.openimaj.math.geometry.point.Point2d; //导入方法依赖的package包/类
@Override
public synchronized void beforeUpdate(MBFImage frame) {
	List<? extends DetectedFace> faces = null;
	if (findKeypoints) {
		faces = engine
				.detectFaces(Transforms.calculateIntensityNTSC(frame));
	} else {
		faces = innerEngine.detectFaces(Transforms
				.calculateIntensityNTSC(frame));
	}

	if (faces.size() > 0) {
		Rectangle r = faces.get(0).getBounds();
		((HaarCascadeDetector) innerEngine)
				.setMinSize((int) (r.width * 0.9));
	} else {
		((HaarCascadeDetector) innerEngine).setMinSize(1);
	}

	for (DetectedFace face : faces) {
		final Shape bounds = face.getBounds();

		MBFImageRenderer renderer = frame.createRenderer();
		renderer.drawPolygon(bounds.asPolygon(), RGBColour.RED);

		if (findKeypoints) {
			for (FacialKeypoint kp : ((KEDetectedFace) face).getKeypoints()) {
				Point2d pt = kp.position.clone();
				pt.translate((float) bounds.minX(), (float) bounds.minY());

				renderer.drawPoint(pt, RGBColour.GREEN, 3);
			}
		}
	}
}
 

import org.openimaj.math.geometry.point.Point2d; //导入方法依赖的package包/类
private static void drawVectors(final FImage[] sequence, final Map<Point2d, Point2d> mv1) {
	final FImage fr = new FImage(sequence[0].width, sequence[0].height);
	for (final Entry<Point2d, Point2d> p : mv1.entrySet()) {
		final Point2d from = p.getKey();
		final Point2d to = p.getValue().copy();
		to.translate(from);

		if (!from.equals(to))
			fr.drawLine(from, to, 1f);
	}
	DisplayUtilities.display(fr);
}
 

import org.openimaj.math.geometry.point.Point2d; //导入方法依赖的package包/类
@Override
public void draw( final MBFImage vis, final int xoffset,
		final int yoffset, final PointList pl )
{
	for( final Point2d p : pl )
	{
		final Point2d pp = new Point2dImpl( p );
		p.translate( xoffset, yoffset );
		vis.drawPoint( pp, RGBColour.RED, 2 );
	}
}
 

import org.openimaj.math.geometry.point.Point2d; //导入方法依赖的package包/类
private void drawBorder(MBFImage ret, TernaryParams params) {
	final int padding = (Integer) params.getTyped(TernaryParams.PADDING);
	final boolean drawTicks = (Boolean) params.getTyped(TernaryParams.TRIANGLE_BORDER_TICKS);
	final Map<Attribute, Object> fontParams = params.getTyped(TernaryParams.TICK_FONT);
	final FontStyle<Float[]> style = FontStyle.parseAttributes(fontParams, ret.createRenderer());
	if (drawTicks) {
		final Triangle drawTri = tri.transform(TransformUtilities.translateMatrix(padding, padding));

		for (int i = 0; i < 3; i++) {
			int paddingx = 0;
			int paddingy = 0;
			switch (i) {
			case 0:
				// the bottom line
				style.setHorizontalAlignment(HorizontalAlignment.HORIZONTAL_CENTER);
				style.setVerticalAlignment(VerticalAlignment.VERTICAL_TOP);
				paddingy = 5;
				break;
			case 1:
				// the right line
				style.setHorizontalAlignment(HorizontalAlignment.HORIZONTAL_LEFT);
				style.setVerticalAlignment(VerticalAlignment.VERTICAL_HALF);
				paddingx = 5;
				paddingy = -5;
				break;
			case 2:
				// the left line
				style.setHorizontalAlignment(HorizontalAlignment.HORIZONTAL_RIGHT);
				style.setVerticalAlignment(VerticalAlignment.VERTICAL_HALF);
				paddingx = -5;
				paddingy = -5;
				break;
			}
			final Point2d start = drawTri.vertices[i];
			final Point2d end = drawTri.vertices[(i + 1) % 3];
			final int nTicks = 10;
			for (int j = 0; j < nTicks + 1; j++) {
				Line2d tickLine = new Line2d(start, end);
				final double length = tickLine.calculateLength();
				// bring its end to the correct position
				double desired = length - j * (length / nTicks);
				if (desired == 0)
					desired = 0.001;
				double scale = desired / length;
				// double overallScale = scale;
				tickLine = tickLine.transform(TransformUtilities.scaleMatrixAboutPoint(scale, scale, start));
				// make it 10 pixels long
				scale = 5f / tickLine.calculateLength();
				tickLine = tickLine.transform(TransformUtilities.scaleMatrixAboutPoint(scale, scale, tickLine.end));
				// Now rotate it by 90 degrees
				tickLine = tickLine.transform(TransformUtilities.rotationMatrixAboutPoint(-Math.PI / 2,
						tickLine.end.getX(), tickLine.end.getY()));
				final int thickness = (Integer) params.getTyped(TernaryParams.TRIANGLE_BORDER_TICK_THICKNESS);
				final Float[] col = params.getTyped(TernaryParams.TRIANGLE_BORDER_COLOUR);
				ret.drawLine(tickLine, thickness, col);

				final Point2d textPoint = tickLine.begin.copy();
				textPoint.translate(paddingx, paddingy);
				// ret.drawText(String.format("%2.2f",overallScale),
				// textPoint, style);
			}

		}
	}
}
 

import org.openimaj.math.geometry.point.Point2d; //导入方法依赖的package包/类
@Override
public void translate(float x, float y) {
	for (final Point2d v : vertices)
		v.translate(x, y);
}