Use the {@link SuperPosition#superposeAndTransform(Point3d[], Point3d[])}
method of the default static SuperPosition algorithm contained in this
Class.
775925
public static Matrix4d superposeAndTransform(Point3d[] fixed,
			Point3d[] moved) {
		superposer.setCentered(false);
		return superposer.superposeAndTransform(fixed, moved);
	}
73968
public static double getRmsdAtOrigin(Point3d[] fixed, Point3d[] moved) {
		superposer.setCentered(true);
		return superposer.getRmsd(fixed, moved);
	}
556387
public static Matrix4d superposeAtOrigin(Point3d[] fixed, Point3d[] moved) {
		superposer.setCentered(true);
		return superposer.superpose(fixed, moved);
	}
1234492
@Override
	protected void doTransform(Position<T> transformable, float comp)
	{
		int fromX = reversed ? this.toX : this.fromX;
		int toX = reversed ? this.fromX : this.toX;
		int fromY = reversed ? this.toY : this.fromY;
		int toY = reversed ? this.fromY : this.toY;

		int x = Math.round(fromX + (toX - fromX) * comp);
		int y = Math.round(fromY + (toY - fromY) * comp);

		transformable.setPosition(x, y);
	}
504770
public Point toProjection(Point point) {
        if (projection != null) {
            point = fromWgs84.transform(point);
        }
        return point;
    }
369889
public static Matrix4d superpose(Point3d[] fixed, Point3d[] moved) {
		superposer.setCentered(false);
		return superposer.superpose(fixed, moved);
	}
23360
@Override
  public void getTransform(Matrix transform) {
    super.getTransform(transform);
    if (mDrawMatrix != null) {
      transform.preConcat(mDrawMatrix);
    }
  }
661944
public Point rotateAndScalePoint(int x, int y, Point reuse) {
		return applyMatrixToPoint(x, y, reuse, mRotateAndScaleMatrix, mOrientation != 0);
	}
543360
@SuppressWarnings({ "unchecked", "rawtypes" })
	@Override
	protected void doTransform(ITransformable transformable, float comp)
	{
		if (listTransformations.size() == 0)
			return;

		for (Transformation transformation : listTransformations)
			transformation.transform(transformable, elapsedTimeCurrentLoop);
	}
1235805
public void transform(Transform3D transform, Point3D pivot) {
		Point3D refPoint = (pivot == null) ? getPivot() : pivot;
		Vector3f v = new Vector3f(this.getEquationComponentA(),this.getEquationComponentB(),this.getEquationComponentC());
    	transform.transform(v);

    	// Update the plane equation according
    	// to the desired normal (computed from
    	// the identity vector and the rotations).
    	
    	// a.x + b.y + c.z + d = 0
    	// where (x,y,z) is the translation point
    	
    	
    	this.set(v.getX(),v.getY(),v.getZ(),- (this.getEquationComponentA()*(refPoint.getX()+transform.m03) +
    				this.getEquationComponentB()*(refPoint.getY()+transform.m13) +
    				this.getEquationComponentC()*(refPoint.getZ()+transform.m23)));
    	
		clearBufferedValues();
	}
515433
public static void translate(Vector3d trans, Point3d[] x) {
		for (Point3d p : x) {
			p.add(trans);
		}
	}
678582
public void transformPose(Matrix4f trans)
    {
        Bone bone = mBones[0];

        bone.LocalMatrix.set(trans);
        bone.WorldMatrix.set(trans);
        bone.Changed = WORLD_POS | WORLD_ROT;
        mNeedSync = true;
        sync();
    }
230112
public Point unrotateAndScalePoint(int x, int y, Point reuse) {
		return applyMatrixToPoint(x, y, reuse, mUnrotateAndScaleMatrix, mOrientation != 0);
	}
808482
public static Point3d[] clonePoint3dArray(Point3d[] x) {
		Point3d[] clone = new Point3d[x.length];
		for (int i = 0; i < x.length; i++) {
			clone[i] = new Point3d(x[i]);
		}
		return clone;
	}
956015
protected void setUpTransform(SingularValueDecomposition svd)
    {
        Vec diag = new DenseVector(dimensions);
        
        double[] s = svd.getSingularValues();
        
        for(int i = 0; i < dimensions; i++)
            diag.set(i, 1.0/Math.sqrt(s[i]+regularization));
        
        transform = new SubMatrix(svd.getU().transpose(), 0, 0, dimensions, s.length).clone();
        
        Matrix.diagMult(diag, transform);
    }
1150632
public void setToInverseL( double a[] ) {
        // TODO reorder these operations to avoid cache misses
        
        // inverts the lower triangular system and saves the result
        // in the upper triangle to minimize cache misses
        for( int i =0; i < n; i++ ) {
            double el_ii = t[i*n+i];
            for( int j = 0; j <= i; j++ ) {
                double sum = (i==j) ? 1.0 : 0;
                for( int k=i-1; k >=j; k-- ) {
                    sum -= t[i*n+k]*a[j*n+k];
                }
                a[j*n+i] = sum / el_ii;
            }
        }
        // solve the system and handle the previous solution being in the upper triangle
        // takes advantage of symmetry
        for( int i=n-1; i>=0; i-- ) {
            double el_ii = t[i*n+i];

            for( int j = 0; j <= i; j++ ) {
                double sum = (i<j) ? 0 : a[j*n+i];
                for( int k=i+1;k<n;k++) {
                    sum -= t[k*n+i]*a[j*n+k];
                }
                a[i*n+j] = a[j*n+i] = sum / el_ii;
            }
        }
    }
1082899
@Override
	public void setFirstAxis(double x, double y, double z, double extent) {
		setFirstAxis(x, y, z, extent, CoordinateSystem3D.getDefaultCoordinateSystem());
	}