我目前正在使用贝塞尔曲线和曲面来绘制著名的犹他茶壶。使用16个控制点的贝塞尔块，我已经能够绘制出茶壶并使用“世界到相机”函数显示茶壶，该函数可以旋转结果中的茶壶，并且我目前正在使用正交投影。
因此，我得到了一个“平面”的茶壶，这是预期的，因为正交投影的目的是保持平行线。
然而，我想使用透视投影使茶壶更加有深度。我的问题是，如何将从“世界到相机”函数返回的3D xyz顶点转换为2D坐标。我希望在z = 0处使用投影平面，并允许用户使用键盘上的箭头键确定焦距和图像大小。
我正在使用Java进行编程，并且已经设置好了所有输入事件处理程序，并且还编写了一个处理基本矩阵乘法的矩阵类。我已经阅读了维基百科和其他资源一段时间，但我仍无法完全掌握如何执行此转换。
现在表示2D / 3D变换的标准方法是使用齐次坐标。 2D为[x，y，w]，3D为[x，y，z，w]。由于在3D中有三个轴以及平移，因此该信息完美地适合4x4变换矩阵中。在本说明中，我将使用列主要矩阵符号。除非另有说明，否则所有矩阵均为4x4。
从3D点到光栅化的点，线或多边形的阶段如下：
这个阶段是实际的投影，因为z不再用作位置的组成部分。
这个计算视野的范围。tan函数使用弧度或角度均可，但是angle必须匹配。请注意，当angle接近180度时，结果会趋近于无穷大。这是一个奇点，因为不可能有如此宽的焦点。如果想要数值稳定性，请将angle保持小于等于179度。
fov = 1.0 / tan(angle/2.0)
请注意，1.0 / tan(45) = 1。这里有人建议只需除以z。结果很清楚。您将获得90度的视场角和1:1的宽高比。像这样使用齐次坐标还有其他几个优点；例如，我们可以执行针对近平面和远平面的裁剪而不将其视为特殊情况。
这是剪辑矩阵的布局。aspectRatio是宽度/高度。因此，x分量的FOV基于y分量的FOV进行缩放。Far和near是系数，它们是近和远裁剪平面的距离。
[fov * aspectRatio][ 0 ][ 0 ][ 0 ]
[ 0 ][ fov ][ 0 ][ 0 ]
[ 0 ][ 0 ][(far+near)/(far-near) ][ 1 ]
[ 0 ][ 0 ][(2*near*far)/(near-far)][ 0 ]
剪裁之后，这是获取屏幕坐标的最终转换。
new_x = (x * Width ) / (2.0 * w) + halfWidth;
new_y = (y * Height) / (2.0 * w) + halfHeight;
#include <vector>
#include <cmath>
#include <stdexcept>
#include <algorithm>
struct Vector
{
Vector() : x(0),y(0),z(0),w(1){}
Vector(float a, float b, float c) : x(a),y(b),z(c),w(1){}
/* Assume proper operator overloads here, with vectors and scalars */
float Length() const
{
return std::sqrt(x*x + y*y + z*z);
}
Vector Unit() const
{
const float epsilon = 1e-6;
float mag = Length();
if(mag < epsilon){
std::out_of_range e("");
throw e;
}
return *this / mag;
}
};
inline float Dot(const Vector& v1, const Vector& v2)
{
return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
}
class Matrix
{
public:
Matrix() : data(16)
{
Identity();
}
void Identity()
{
std::fill(data.begin(), data.end(), float(0));
data[0] = data[5] = data[10] = data[15] = 1.0f;
}
float& operator[](size_t index)
{
if(index >= 16){
std::out_of_range e("");
throw e;
}
return data[index];
}
Matrix operator*(const Matrix& m) const
{
Matrix dst;
int col;
for(int y=0; y<4; ++y){
col = y*4;
for(int x=0; x<4; ++x){
for(int i=0; i<4; ++i){
dst[x+col] += m[i+col]*data[x+i*4];
}
}
}
return dst;
}
Matrix& operator*=(const Matrix& m)
{
*this = (*this) * m;
return *this;
}
/* The interesting stuff */
void SetupClipMatrix(float fov, float aspectRatio, float near, float far)
{
Identity();
float f = 1.0f / std::tan(fov * 0.5f);
data[0] = f*aspectRatio;
data[5] = f;
data[10] = (far+near) / (far-near);
data[11] = 1.0f; /* this 'plugs' the old z into w */
data[14] = (2.0f*near*far) / (near-far);
data[15] = 0.0f;
}
std::vector<float> data;
};
inline Vector operator*(const Vector& v, const Matrix& m)
{
Vector dst;
dst.x = v.x*m[0] + v.y*m[4] + v.z*m[8 ] + v.w*m[12];
dst.y = v.x*m[1] + v.y*m[5] + v.z*m[9 ] + v.w*m[13];
dst.z = v.x*m[2] + v.y*m[6] + v.z*m[10] + v.w*m[14];
dst.w = v.x*m[3] + v.y*m[7] + v.z*m[11] + v.w*m[15];
return dst;
}
typedef std::vector<Vector> VecArr;
VecArr ProjectAndClip(int width, int height, float near, float far, const VecArr& vertex)
{
float halfWidth = (float)width * 0.5f;
float halfHeight = (float)height * 0.5f;
float aspect = (float)width / (float)height;
Vector v;
Matrix clipMatrix;
VecArr dst;
clipMatrix.SetupClipMatrix(60.0f * (M_PI / 180.0f), aspect, near, far);
/* Here, after the perspective divide, you perform Sutherland-Hodgeman clipping
by checking if the x, y and z components are inside the range of [-w, w].
One checks each vector component seperately against each plane. Per-vertex
data like colours, normals and texture coordinates need to be linearly
interpolated for clipped edges to reflect the change. If the edge (v0,v1)
is tested against the positive x plane, and v1 is outside, the interpolant
becomes: (v1.x - w) / (v1.x - v0.x)
I skip this stage all together to be brief.
*/
for(VecArr::iterator i=vertex.begin(); i!=vertex.end(); ++i){
v = (*i) * clipMatrix;
v /= v.w; /* Don't get confused here. I assume the divide leaves v.w alone.*/
dst.push_back(v);
}
/* TODO: Clipping here */
for(VecArr::iterator i=dst.begin(); i!=dst.end(); ++i){
i->x = (i->x * (float)width) / (2.0f * i->w) + halfWidth;
i->y = (i->y * (float)height) / (2.0f * i->w) + halfHeight;
}
return dst;
}
要获取透视校正后的坐标，只需通过z坐标进行除法运算：
xc = x / z
yc = y / z
假设相机在(0, 0, 0)处，你正在将其投影到z = 1的平面上——否则你需要相对于相机来翻译坐标。
对于曲线存在一些复杂性，因为投影一个三维贝塞尔曲线的点通常不会给出通过投影点绘制的二维贝塞尔曲线的相同点。
只需使用两个类，即可使用Commons Math: The Apache Commons Mathematics Library将3D点投影到2D上。
Java Swing示例。
import org.apache.commons.math3.geometry.euclidean.threed.Plane;
import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
Plane planeX = new Plane(new Vector3D(1, 0, 0));
Plane planeY = new Plane(new Vector3D(0, 1, 0)); // Must be orthogonal plane of planeX
void drawPoint(Graphics2D g2, Vector3D v) {
g2.drawLine(0, 0,
(int) (world.unit * planeX.getOffset(v)),
(int) (world.unit * planeY.getOffset(v)));
}
protected void paintComponent(Graphics g) {
super.paintComponent(g);
drawPoint(g2, new Vector3D(2, 1, 0));
drawPoint(g2, new Vector3D(0, 2, 0));
drawPoint(g2, new Vector3D(0, 0, 2));
drawPoint(g2, new Vector3D(1, 1, 1));
}
现在您只需要更新planeX和planeY来改变透视投影，就可以得到如下的效果:
从上面看屏幕，你会得到x和z轴。
从侧面看屏幕，您将得到y和z轴。
使用三角函数计算顶部和侧面视图的焦距，即眼睛与屏幕中心之间的距离，这是由屏幕的视野决定的。 这使得两个直角三角形背对背。
hw = 屏幕宽度 / 2
hh = 屏幕高度 / 2
fl_top = hw / tan(θ/2)
fl_side = hh / tan(θ/2)
然后取平均焦距。
fl_average = (fl_top + fl_side) / 2
现在用基本算术计算新的x和新的y，因为由3D点和眼点组成的较大直角三角形与由2D点和眼点组成的较小三角形是全等的。
x' = (x * fl_top) / (z + fl_top)
y' = (y * fl_top) / (z + fl_top)
或者你可以简单地设置
x' = x / (z + 1)
和
y' = y / (z + 1)
#include <vector>
#include <cmath>
#include <stdexcept>
#include <algorithm>
#define M_PI 3.14159
#define NEAR_Z 0.5
#define FAR_Z 2.5
struct Vector
{
float x;
float y;
float z;
float w;
Vector() : x( 0 ), y( 0 ), z( 0 ), w( 1 ) {}
Vector( float a, float b, float c ) : x( a ), y( b ), z( c ), w( 1 ) {}
/* Assume proper operator overloads here, with vectors and scalars */
float Length() const
{
return std::sqrt( x*x + y*y + z*z );
}
Vector& operator*=(float fac) noexcept
{
x *= fac;
y *= fac;
z *= fac;
return *this;
}
Vector operator*(float fac) const noexcept
{
return Vector(*this)*=fac;
}
Vector& operator/=(float div) noexcept
{
return operator*=(1/div); // avoid divisions: they are much
// more costly than multiplications
}
Vector Unit() const
{
const float epsilon = 1e-6;
float mag = Length();
if (mag < epsilon) {
std::out_of_range e( "" );
throw e;
}
return Vector(*this)/=mag;
}
};
inline float Dot( const Vector& v1, const Vector& v2 )
{
return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
}
class Matrix
{
public:
Matrix() : data( 16 )
{
Identity();
}
void Identity()
{
std::fill( data.begin(), data.end(), float( 0 ) );
data[0] = data[5] = data[10] = data[15] = 1.0f;
}
float& operator[]( size_t index )
{
if (index >= 16) {
std::out_of_range e( "" );
throw e;
}
return data[index];
}
const float& operator[]( size_t index ) const
{
if (index >= 16) {
std::out_of_range e( "" );
throw e;
}
return data[index];
}
Matrix operator*( const Matrix& m ) const
{
Matrix dst;
int col;
for (int y = 0; y<4; ++y) {
col = y * 4;
for (int x = 0; x<4; ++x) {
for (int i = 0; i<4; ++i) {
dst[x + col] += m[i + col] * data[x + i * 4];
}
}
}
return dst;
}
Matrix& operator*=( const Matrix& m )
{
*this = (*this) * m;
return *this;
}
/* The interesting stuff */
void SetupClipMatrix( float fov, float aspectRatio )
{
Identity();
float f = 1.0f / std::tan( fov * 0.5f );
data[0] = f*aspectRatio;
data[5] = f;
data[10] = (FAR_Z + NEAR_Z) / (FAR_Z- NEAR_Z);
data[11] = 1.0f; /* this 'plugs' the old z into w */
data[14] = (2.0f*NEAR_Z*FAR_Z) / (NEAR_Z - FAR_Z);
data[15] = 0.0f;
}
std::vector<float> data;
};
inline Vector operator*( const Vector& v, Matrix& m )
{
Vector dst;
dst.x = v.x*m[0] + v.y*m[4] + v.z*m[8] + v.w*m[12];
dst.y = v.x*m[1] + v.y*m[5] + v.z*m[9] + v.w*m[13];
dst.z = v.x*m[2] + v.y*m[6] + v.z*m[10] + v.w*m[14];
dst.w = v.x*m[3] + v.y*m[7] + v.z*m[11] + v.w*m[15];
return dst;
}
typedef std::vector<Vector> VecArr;
VecArr ProjectAndClip( int width, int height, const VecArr& vertex )
{
float halfWidth = (float)width * 0.5f;
float halfHeight = (float)height * 0.5f;
float aspect = (float)width / (float)height;
Vector v;
Matrix clipMatrix;
VecArr dst;
clipMatrix.SetupClipMatrix( 60.0f * (M_PI / 180.0f), aspect);
/* Here, after the perspective divide, you perform Sutherland-Hodgeman clipping
by checking if the x, y and z components are inside the range of [-w, w].
One checks each vector component seperately against each plane. Per-vertex
data like colours, normals and texture coordinates need to be linearly
interpolated for clipped edges to reflect the change. If the edge (v0,v1)
is tested against the positive x plane, and v1 is outside, the interpolant
becomes: (v1.x - w) / (v1.x - v0.x)
I skip this stage all together to be brief.
*/
for (VecArr::const_iterator i = vertex.begin(); i != vertex.end(); ++i) {
v = (*i) * clipMatrix;
v /= v.w; /* Don't get confused here. I assume the divide leaves v.w alone.*/
dst.push_back( v );
}
/* TODO: Clipping here */
for (VecArr::iterator i = dst.begin(); i != dst.end(); ++i) {
i->x = (i->x * (float)width) / (2.0f * i->w) + halfWidth;
i->y = (i->y * (float)height) / (2.0f * i->w) + halfHeight;
}
return dst;
}
#pragma once
operator/=更改了。您是对的，它应该改变向量本身。 - antipatternUnit() 中如果长度小于1e-6就抛出一个错误呢？如果三个向量分量都更小怎么办？要么什么都不做（如果长度为0则返回NaN），要么只检查长度是否等于0。 - Walter我不确定您提问的水平。看起来您已经在网上找到了公式，现在只是想理解它的作用。如果您的问题是这样的，我可以给出以下回答：
我知道这是一个老话题，但你的插图不正确，源代码设置剪辑矩阵是正确的。
[fov * aspectRatio][ 0 ][ 0 ][ 0 ]
[ 0 ][ fov ][ 0 ][ 0 ]
[ 0 ][ 0 ][(far+near)/(far-near) ][(2*near*far)/(near-far)]
[ 0 ][ 0 ][ 1 ][ 0 ]
关于您的事项，有一些补充：
这个剪辑矩阵仅在您投影到静态二维平面时才有效，如果您想要添加相机移动和旋转：
viewMatrix = clipMatrix * cameraTranslationMatrix4x4 * cameraRotationMatrix4x4;
这让你可以旋转2D平面并将其移动..-
你可能想使用球体来调试你的系统，以确定你是否拥有良好的视野。如果你的视野太宽，球体在屏幕边缘会变形成更椭圆形状，指向框架中心。解决这个问题的方法是通过将三维点的x和y坐标乘以一个标量来放大框架，然后通过类似的因子缩小你的对象或世界。然后你就可以获得整个框架上漂亮均匀的圆形球体。
我几乎感到尴尬，因为我花了一整天才弄清楚这个问题，而且我几乎相信这里存在某种神秘的几何现象，需要不同的方法来解决。
然而，通过渲染球体校准缩放-视野系数的重要性不言而喻。如果你不知道你的宇宙的“适居区”在哪里，你最终会走在太阳上并放弃这个项目。你希望能够在你的视野范围内的任何地方渲染一个球体，并使其呈现出圆形。在我的项目中，单位球体与我描述的区域相比非常巨大。
此外，还有义务的维基百科条目： 球坐标系