Unproject a screen coordinate (at depth 0) to 3D model coordinates.

@param x X
@param y Y
@param z Z
@return model coordinates
487795
public double[] unproject(double x, double y, double z) {
    double[] out = new double[3];
    unproject(x, y, z, out);
    return out;
  }
1138744
public Point2d toModelCoordinates(double screenX, double screenY) {
        try {
            double[] dest = new double[2];
            double[] src = new double[]{screenX, screenY};
            transform.inverseTransform(src, 0, dest, 0, 1);
            return new Point2d(dest[0], dest[1]);
        } catch (NoninvertibleTransformException n) {
            return new Point2d(0, 0);
        }
    }
71997
protected Scale from(float x, float y, float z)
	{
		fromX = x;
		fromY = y;
		fromZ = z;
		return this;
	}
74387
public Vector3d cross(double x, double y, double z) {
        return cross(x, y, z, thisOrNew());
    }
965587
public Vector4f unprojectInv(Vector3fc winCoords, int[] viewport, Vector4f dest) {
        return unprojectInv(winCoords.x(), winCoords.y(), winCoords.z(), viewport, dest);
    }
1344080
@SuppressWarnings("static-method")
	public Point3dfx newPoint(DoubleProperty x, DoubleProperty y, DoubleProperty z) {
		return new Point3dfx(x, y, z);
	}
711114
public Matrix4d unprojectInvRay(double winX, double winY, int[] viewport, Vector3d originDest, Vector3d dirDest) {
        double ndcX = (winX-viewport[0])/viewport[2]*2.0-1.0;
        double ndcY = (winY-viewport[1])/viewport[3]*2.0-1.0;
        double px = m00 * ndcX + m10 * ndcY + m30;
        double py = m01 * ndcX + m11 * ndcY + m31;
        double pz = m02 * ndcX + m12 * ndcY + m32;
        double invNearW = 1.0 / (m03 * ndcX + m13 * ndcY - m23 + m33);
        double nearX = (px - m20) * invNearW;
        double nearY = (py - m21) * invNearW;
        double nearZ = (pz - m22) * invNearW;
        double invFarW = 1.0 / (m03 * ndcX + m13 * ndcY + m23 + m33);
        double farX = (px + m20) * invFarW;
        double farY = (py + m21) * invFarW;
        double farZ = (pz + m22) * invFarW;
        originDest.x = nearX; originDest.y = nearY; originDest.z = nearZ;
        dirDest.x = farX - nearX; dirDest.y = farY - nearY; dirDest.z = farZ - nearZ;
        return this;
    }
463179
public Point2d toScreenCoordinates(double modelX, double modelY) {
        double[] dest = new double[2];
        transform.transform(new double[]{modelX, modelY}, 0, dest, 0, 1);
        return new Point2d(dest[0], dest[1]);
    }
230112
public Point unrotateAndScalePoint(int x, int y, Point reuse) {
		return applyMatrixToPoint(x, y, reuse, mUnrotateAndScaleMatrix, mOrientation != 0);
	}
1084973
public Matrix3f scaling(float x, float y, float z) {
        MemUtil.INSTANCE.zero(this);
        m00 = x;
        m11 = y;
        m22 = z;
        return this;
    }
349466
public static INDArray neq(INDArray x, INDArray y, INDArray z, int... dimensions) {
        if(dimensions == null || dimensions.length == 0) {
            validateShapesNoDimCase(x,y,z);
            return Nd4j.getExecutioner().exec(new OldNotEqualTo(x,y,z));
        }

        return Nd4j.getExecutioner().exec(new BroadcastNotEqual(x,y,z,dimensions));
    }
338275
public Vector3d div(double x, double y, double z, Vector3d dest) {
        dest.x = this.x / x;
        dest.y = this.y / y;
        dest.z = this.z / z;
        return dest;
    }
1004352
public Vector4f transformProject(float x, float y, float z, float w, Vector4f dest) {
        dest.x = x;
        dest.y = y;
        dest.z = z;
        dest.w = w;
        return dest.mulProject(this);
    }
904884
public void rotateByAxis(float angle, float x, float y, float z) {
        NativeTransform.rotateByAxis(getNative(), angle * TO_RADIANS, x, y, z);
    }
206884
public Coordinate viewToWorld(Coordinate coordinate) {
		if (coordinate != null) {
			Vector2D position = new Vector2D(coordinate);
			double inverseScale = 1 / mapView.getCurrentScale();
			position.scale(inverseScale, -inverseScale);

			Bbox bounds = mapView.getBounds();
			// -cam: center X axis around cam. +bbox.w/2: to place the origin in the center of the screen
			double translateX = -mapView.getViewState().getX() + (bounds.getWidth() / 2);
			double translateY = -mapView.getViewState().getY() - (bounds.getHeight() / 2); // Inverted Y-axis here...
			position.translate(-translateX, -translateY);
			// TODO: implement rotation support.
			return new Coordinate(position.getX(), position.getY());
		}
		return null;
	}
231641
public void set(double x, double y, double z) {
		assert Vector3D.isUnitVector(x, y, z) : AssertMessages.normalizedParameters(0, 1, 2);
		if ((x != getX() || y != getY() || z != getZ()) && !isBound()) {
			final Vector3dfx v = super.get();
			v.set(x, y, z);
			fireValueChangedEvent();
		}
	}
361236
public Point3D getXYZ() {
		if (isEmptyImpl())
			throw new GeometryException(
					"This operation should not be performed on an empty geometry.");

		Point3D pt = new Point3D();
		pt.x = m_attributes[0];
		pt.y = m_attributes[1];
		if (m_description.hasZ())
			pt.z = m_attributes[2];
		else
			pt.z = VertexDescription.getDefaultValue(Semantics.Z);

		return pt;
	}