我目前正在使用贝塞尔曲线和曲面来绘制著名的犹他茶壶。使用 16 个控制点的 Bezier 补丁，我已经能够绘制茶壶并使用“世界到相机”功能显示它，该功能可以旋转生成的茶壶，目前正在使用正交投影。
结果是我有一个“扁平”茶壶，这是预期的，因为正交投影的目的是保留平行线。
但是，我想使用透视投影来给茶壶深度。我的问题是，如何获取从“世界到相机”函数返回的 3D xyz 顶点，并将其转换为 2D 坐标。我想在 z=0 处使用投影平面，并允许用户使用键盘上的箭头键确定焦距和图像大小。
我正在用java编程并设置了所有输入事件处理程序，并且还编写了一个处理基本矩阵乘法的矩阵类。我已经阅读了一段时间的维基百科和其他资源，但我不太了解如何执行这种转换。
我看到这个问题有点老了，但我还是决定给那些通过搜索找到这个问题的人一个答案。
现在表示 2D/3D 变换的标准方法是使用齐次坐标。[x,y,w]用于 2D，[x,y,z,w]用于 3D。由于您在 3D 和平移中都有三个轴，因此该信息完全适合 4x4 变换矩阵。在本说明中，我将使用列主矩阵表示法。除非另有说明，否则所有矩阵都是 4x4。
从 3D 点到光栅化点、线或多边形的阶段如下所示：
这个阶段是实际的投影，因为 z 不再用作位置中的组件。
这将计算视野。tan 采用弧度还是度数无关紧要，但角度必须匹配。请注意，当角度接近 180 度时，结果会达到无穷大。这是一个奇点，因为不可能有这么宽的焦点。如果您想要数值稳定性，请保持角度小于或等于 179 度。
fov = 1.0 / tan(angle/2.0)
还要注意 1.0 / tan(45) = 1。这里的其他人建议只除以 z。这里的结果很清楚。您将获得 90 度的 FOV 和 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;
}
如果你还在思考这个问题，OpenGL 规范对于所涉及的数学来说是一个非常好的参考。http://www.devmaster.net/上的 DevMaster 论坛也有很多与软件光栅化器相关的好文章。
我想这可能会回答你的问题。这是我在那里写的：
这是一个非常笼统的答案。假设相机在 (Xc, Yc, Zc) 并且您要投影的点是 P = (X, Y, Z)。从相机到您要投影到的 2D 平面的距离为 F（因此平面方程为 Z-Zc=F）。P 投影到平面上的二维坐标为 (X', Y')。
然后，非常简单：
X' = ((X - Xc) * (F/Z)) + Xc
Y' = ((Y - Yc) * (F/Z)) + Yc
如果您的相机是原点，那么这将简化为：
X' = X * (F/Z)
Y' = Y * (F/Z)
要获得透视校正的坐标，只需除以z坐标：
xc = x / z
yc = y / z
上面的工作假设相机在(0, 0, 0)并且你正在投影到平面上z = 1- 你需要翻译相对于相机的坐标。
曲线有一些复杂性，因为投影 3D 贝塞尔曲线的点通常不会为您提供与通过投影点绘制 2D 贝塞尔曲线相同的点。
您可以使用以下方法在 2D 中投影 3D 点： Commons Math：只有两个类的 Apache Commons 数学库。
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 = screen_width / 2
hh = screen_height / 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)
我不确定你在哪个级别问这个问题。听起来您好像在网上找到了公式，只是想了解它的作用。在阅读您的问题时，我提供：
所有答案都解决了标题中提出的问题。但是，我想添加一个隐含在文本中的警告。贝塞尔面片用于表示表面，但您不能只变换面片的点并将面片细分为多边形，因为这会导致几何变形。但是，您可以先使用转换的屏幕容差将面片细分为多边形，然后再转换多边形，或者您可以将贝塞尔面片转换为有理的贝塞尔面片，然后使用屏幕空间容差进行面片细分。前者更容易，但后者更适合生产系统。
我怀疑你想要更简单的方法。为此，您将通过反透视变换的雅可比行列式的范数缩放屏幕容差，并使用它来确定模型空间中所需的镶嵌量（计算前向雅可比行列式可能更容易，然后将其反转，然后采取规范）。请注意，此规范与位置有关，您可能希望根据视角在多个位置对其进行评估。还要记住，由于射影变换是有理的，因此您需要应用商规则来计算导数。
感谢@Mads Elvenheim 提供了正确的示例代码。我已经修复了代码中的小语法错误（只是一些const问题和明显缺少的运算符）。此外，near和far在 vs. 中的含义也大不相同。
为了您的愉快，这里是可编译的（MSVC2013）版本。玩得开心。请注意，我已使 NEAR_Z 和 FAR_Z 保持不变。你可能不希望这样。
#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
我知道这是一个老话题，但你的插图不正确，源代码正确设置了剪辑矩阵。
[fov * aspectRatio][ 0 ][ 0 ][ 0 ]
[ 0 ][ fov ][ 0 ][ 0 ]
[ 0 ][ 0 ][(far+near)/(far-near) ][(2*near*far)/(near-far)]
[ 0 ][ 0 ][ 1 ][ 0 ]
你的东西的一些补充：
如果要添加相机移动和旋转，此剪辑矩阵仅适用于在静态 2D 平面上投影：
viewMatrix = clipMatrix * cameraTranslationMatrix4x4 * cameraRotationMatrix4x4;
这使您可以旋转 2D 平面并移动它..-
您可能希望使用球体调试系统以确定您是否具有良好的视野。如果它太宽，屏幕边缘的球体会变形为指向框架中心的更多椭圆形。这个问题的解决方案是放大框架，通过将 3 维点的 x 和 y 坐标乘以一个标量，然后将您的对象或世界缩小一个类似的因子。然后你会在整个框架上得到漂亮的均匀圆形球体。
我几乎很尴尬，我花了一整天的时间才弄清楚这一点，我几乎确信这里发生了一些令人毛骨悚然的神秘几何现象，需要一种不同的方法。
然而，通过渲染球体来校准缩放视图系数的重要性怎么强调都不为过。如果你不知道你的宇宙的“宜居带”在哪里，你最终会走在太阳上，放弃这个项目。您希望能够在您的视图中的任何位置渲染一个球体并让它看起来是圆形的。在我的项目中，与我所描述的区域相比，单位球体是巨大的。
此外，必填的维基百科条目： 球坐标系