将对象从3D坐标系转换为2D显示空间(立方体)

最新推荐文章于 2024-04-19 15:03:23 发布
最新推荐文章于 2024-04-19 15:03:23 发布
阅读量1k 收藏 1
点赞数
分类专栏： 3D 文章标签： 3d 算法 图像处理 视觉检测 3dsmax
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kirsten111111/article/details/127896359
版权

将对象从3D坐标系转换为2D显示空间(立方体)

现在，我们将研究如何将对象的顶点从其本地3D坐标系转换为2D屏幕显示空间。多个对象位于3D世界坐标空间中。单个顶点具有X，Y，Z坐标。这些必须从3D世界空间转换为正在看它们的相机的3D坐标空间。从这里，将顶点从相机空间（也称为视图空间）转换为3D屏幕空间，然后最终在2D屏幕显示空间中显示。形成三角形的三个顶点的组在此过程的早期阶段保持“连接”，直到将它们双线插值进行双线插值，以产生代表三角形以显示在屏幕上的三角形的单个片段的集合。每个片段都有一个3D屏幕X，Y，Z坐标，可用于隐藏表面拆卸等物品。要从3D对象空间移动到3D屏幕空间，使用了模型视图投影矩阵。这些阶段中的每个阶段将在以下小节中更详细地探讨。

我们将从一个由两个三角形组成的对象开始，然后是一个涉及立方体的示例，然后是一组立方体。

两个三角形对象

// ***************************************************
  /* THE DATA
   */
  // anticlockwise/counterclockwise ordering
  private float[] vertices = {      
    // position (x,y,z), colour (r,g,b),    tex coords (s,t)
    -0.5f,  0.5f, 0.0f,  1.0f, 0.0f, 0.0f,  0.0f, 1.0f,  // top left
    -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,  0.0f, 0.0f,  // bottom left
     0.5f, -0.5f, 0.0f,  0.0f, 0.0f, 1.0f,  1.0f, 0.0f,  // bottom right
     0.5f,  0.5f, 0.0f,  1.0f, 1.0f, 1.0f,  1.0f, 1.0f   // top right
  };
  
  private int vertexStride = 8;        // 8 floats per vertex
  private int vertexXYZFloats = 3;     // 3 floats for the position
  private int vertexColourFloats = 3;  // 3 flopats for the colour
  private int vertexTexFloats = 2;     // 2 floats for the texture coordinates
  
  private int[] indices = {            // Note that we start from 0
      0, 1, 2,                         // Triangle 1 is made up of vertices 0, 1 and 2
                                       // in anticlockwise ordering
      0, 2, 3                          // Triangle 2 is made up of vertices 0, 2 and 3 
                                       // in anticlockwise ordering
  };

上述代码给出数据结构和下一个代码给出了渲染方法。绘制了两个三角形，并用瓦特（Watt）书的前盖绘制纹理。这两个三角形已从观看者旋转，因此从观看者中看到。

public void render(GL3 gl) {
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
  
    double elapsedTime = getSeconds()-startTime;
    
    Mat4 projectionMatrix = Mat4Transform.perspective(45, aspect);
    
    float zposition = 2f;
    //float zposition = 2f+(float)(Math.sin(Math.toRadians(elapsedTime*50)));
    Vec3 position = new Vec3(0,0,zposition);
    Mat4 viewMatrix = Mat4Transform.lookAt(position, new Vec3(0,0,0), new Vec3(0,1,0));
    
    float angle = -55f;
    //float angle = (float)(-115*Math.sin(Math.toRadians(elapsedTime*50)));
    Mat4 modelMatrix = Mat4Transform.rotateAroundX(angle);
    
    Mat4 mvpMatrix = Mat4.multiply(viewMatrix, modelMatrix);
    mvpMatrix = Mat4.multiply(projectionMatrix, mvpMatrix);
    
    shader.use(gl);
    shader.setFloatArray(gl, "model", modelMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "view", viewMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "projection", projectionMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "mvpMatrix", mvpMatrix.toFloatArrayForGLSL());
    
    gl.glActiveTexture(GL.GL_TEXTURE0);
    gl.glBindTexture(GL.GL_TEXTURE_2D, textureId1[0]);
  
    gl.glBindVertexArray(vertexArrayId[0]);
    gl.glDrawElements(GL.GL_TRIANGLES, indices.length, GL.GL_UNSIGNED_INT, 0);
    gl.glBindVertexArray(0);
  }

使用静态方法mat4transform.perspective（）创建投影矩阵。然后使用静态方法mat4transform.lookat（从，到，向上）创建视图矩阵。这需要三个参数：相机位置，相机正在看的目标以及世界的名义向量；在此示例中，摄像机处于位置（0,0,2），着眼于世界原产地，最初的向量（0,1,0）。革兰氏– SCHMIDT过程（如讲座中所述）用于为视图创建坐标框架（即相机）。

选择–55度的角度将两个三角形旋转X轴旋转，该轴将旋转远离观看器的顶部。静态方法mat4transform.rotatearoundx（）用于设置所需的模型转换矩阵。

在下一步中，计算模型视图投影矩阵。重要的是：请记住，矩阵在它们正在转换的顶点之前。因此，它们是按照投影，视图，模型的，因此模型矩阵是第一个应用于顶点的。

然后，使用单独的统一制度将ModelMatrix，ViewMatrix，IdjotectionMatrix和MVPMATRIX的每一个都传递到顶点着色器。为此，必须首先将4x4矩阵转换为浮子数组。方法Mat4.tofloatarrayforglsl（）用于执行此操作。它将行柱有序的矩阵转换为存储在浮子数组中的列有序矩阵，这是顶点着色器中使用的数据类型中所需的内容。还将一种新方法添加到着色器类中，以在顶点着色器中设置相关的统一。

在此示例中，我已经将所有4个矩阵传递给着色器，以证明我们可以（i）将模型，视图和投影矩阵分别传递到着色器，或者（ii）将它们组合到CPU上的模型视频预测矩阵中。然后将其传递给着色器，或（iii）同时使用。我们还可以将单个矩阵传递，并将其组合成GPU上的模型观察矩阵 - 这就是Joey在他的教程中所做的。在顶点着色器中编写模型视图预测矩阵的问题是，然后重复对象中每个顶点的相同计算。但是，这对于某些程序可能是必要的，具体取决于所需的内容。在将来的程序中，我们将仅通过模型矩阵和模型视图预测矩阵。原因将在稍后进行解释。

接下来要看的是顶点着色器，该阴影器在下一个代码中给出。大多数应该对您熟悉。新的制服被称为MAT4型，例如统一MAT4 MVPMATRIX，其中包含从主程序发送的模型视图投影矩阵。这用于乘以顶点的位置，以将其转换为3D屏幕空间（或已知的剪辑空间）。评论的输出线显示，可以在顶点着色器中计算模型观看预测矩阵。

#version 330 core

layout (location = 0) in vec3 position;
layout (location = 1) in vec3 color;
layout (location = 2) in vec2 texCoord;

out vec3 aColor;
out vec2 aTexCoord;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
uniform mat4 mvpMatrix;

void main() {
  //mat4 mvpMatrix2 = projection * view * model;
  //gl_Position = mvpMatrix2 * vec4(position, 1.0);
  
  gl_Position = mvpMatrix * vec4(position, 1.0);
  
  aColor = color;
  aTexCoord = texCoord;
}

顶点着色器的每个实例在不同的顶点上执行相同的操作。 所有顶点都发送到管道的下一个阶段，在那里它们被重新连接在一起以制作三角形，然后将其栅格隔开以产生一组由片段着色器处理的片段。 片段着色器不需要从我们以前的程序中更改。 它只是使用相关纹理坐标来算出片段的颜色。 我们在三角数据结构中使用的颜色属性被忽略（因此可以从示例中删除）。

我们现在有一个工作的3D世界。

(1) 一个立方体对象
立方体的每个面都有纹理坐标在0.0,0.0至1.0,1.0的范围内

// ***************************************************
  /* THE DATA
   */
  // anticlockwise/counterclockwise ordering
  
   private float[] vertices = new float[] {  // x,y,z, colour, s,t
      -0.5f, -0.5f, -0.5f,  1.0f, 0.0f, 0.0f,  0.0f, 0.0f,  // 0
      -0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 0.0f,  1.0f, 0.0f,  // 1
      -0.5f,  0.5f, -0.5f,  1.0f, 0.0f, 0.0f,  0.0f, 1.0f,  // 2
      -0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,  1.0f, 1.0f,  // 3
       0.5f, -0.5f, -0.5f,  1.0f, 0.0f, 0.0f,  1.0f, 0.0f,  // 4
       0.5f, -0.5f,  0.5f,  1.0f, 0.0f, 0.0f,  0.0f, 0.0f,  // 5
       0.5f,  0.5f, -0.5f,  1.0f, 0.0f, 0.0f,  1.0f, 1.0f,  // 6
       0.5f,  0.5f,  0.5f,  1.0f, 0.0f, 0.0f,  0.0f, 1.0f,  // 7

      -0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,  1.0f, 0.0f,  // 8
      -0.5f, -0.5f,  0.5f,  0.0f, 1.0f, 0.0f,  0.0f, 0.0f,  // 9
      -0.5f,  0.5f, -0.5f,  0.0f, 1.0f, 0.0f,  1.0f, 1.0f,  // 10
      -0.5f,  0.5f,  0.5f,  0.0f, 1.0f, 0.0f,  0.0f, 1.0f,  // 11
       0.5f, -0.5f, -0.5f,  0.0f, 1.0f, 0.0f,  0.0f, 0.0f,  // 12
       0.5f, -0.5f,  0.5f,  0.0f, 1.0f, 0.0f,  1.0f, 0.0f,  // 13
       0.5f,  0.5f, -0.5f,  0.0f, 1.0f, 0.0f,  0.0f, 1.0f,  // 14
       0.5f,  0.5f,  0.5f,  0.0f, 1.0f, 0.0f,  1.0f, 1.0f,  // 15

      -0.5f, -0.5f, -0.5f,  0.0f, 0.0f, 1.0f,  0.0f, 0.0f,  // 16
      -0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 1.0f,  0.0f, 1.0f,  // 17
      -0.5f,  0.5f, -0.5f,  0.0f, 0.0f, 1.0f,  0.0f, 1.0f,  // 18
      -0.5f,  0.5f,  0.5f,  0.0f, 0.0f, 1.0f,  0.0f, 0.0f,  // 19
       0.5f, -0.5f, -0.5f,  0.0f, 0.0f, 1.0f,  1.0f, 0.0f,  // 20
       0.5f, -0.5f,  0.5f,  0.0f, 0.0f, 1.0f,  1.0f, 1.0f,  // 21
       0.5f,  0.5f, -0.5f,  0.0f, 0.0f, 1.0f,  1.0f, 1.0f,  // 22
       0.5f,  0.5f,  0.5f,  0.0f, 0.0f, 1.0f,  1.0f, 0.0f   // 23
     };
    
     private int[] indices =  new int[] {
      0,1,3, // x -ve 
      3,2,0, // x -ve
      4,6,7, // x +ve
      7,5,4, // x +ve
      9,13,15, // z +ve
      15,11,9, // z +ve
      8,10,14, // z -ve
      14,12,8, // z -ve
      16,20,21, // y -ve
      21,17,16, // y -ve
      23,22,18, // y +ve
      18,19,23  // y +ve
    };
    
  private int vertexStride = 8;
  private int vertexXYZFloats = 3;
  private int vertexColourFloats = 3;
  private int vertexTexFloats = 2;

给出渲染方法和随附的方法，用于防止渲染方法变得混乱。 getModelMatrix（）返回模型变换矩阵。 在这里，它只是返回身份矩阵。 GetViewMatrix（）将相机设置为位置（2,3,4），查看原点（0,0,0），名义上向量为（0,1,0）。

 public void render(GL3 gl) {
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

    Mat4 projectionMatrix = Mat4Transform.perspective(45, aspect);
    Mat4 viewMatrix = getViewMatrix();
    Mat4 modelMatrix = getModelMatrix();
    Mat4 mvpMatrix = Mat4.multiply(projectionMatrix, Mat4.multiply(viewMatrix, modelMatrix));
    
    shader.use(gl);
    shader.setFloatArray(gl, "model", modelMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "view", viewMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "projection", projectionMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "mvpMatrix", mvpMatrix.toFloatArrayForGLSL());
    
    gl.glActiveTexture(GL.GL_TEXTURE0);
    gl.glBindTexture(GL.GL_TEXTURE_2D, textureId1[0]);
  
    gl.glBindVertexArray(vertexArrayId[0]);
    gl.glDrawElements(GL.GL_TRIANGLES, indices.length, GL.GL_UNSIGNED_INT, 0);
    gl.glBindVertexArray(0);
  }
  
  private Mat4 getModelMatrix() {
    double elapsedTime = getSeconds()-startTime;
    //float angle = -55;
    //float angle = (float)(-115*Math.sin(Math.toRadians(elapsedTime*50)));
    Mat4 modelMatrix = new Mat4(1);
    //modelMatrix = Mat4.multiply(Mat4Transform.rotateAroundY(angle), modelMatrix);
    //modelMatrix = Mat4.multiply(Mat4Transform.rotateAroundX(angle), modelMatrix);
    return modelMatrix;
  }
  
  private Mat4 getViewMatrix() {
    double elapsedTime = getSeconds()-startTime;
    float xposition = 2;
    float yposition = 3;
    float zposition = 4;
    //float xposition = 3.0f*(float)(Math.sin(Math.toRadians(elapsedTime*50)));
    //float zposition = 3.0f*(float)(Math.cos(Math.toRadians(elapsedTime*50)));
    Mat4 viewMatrix = Mat4Transform.lookAt(new Vec3(xposition,yposition,zposition), 
                                           new Vec3(0,0,0), new Vec3(0,1,0));
    return viewMatrix;
  }

练习
首先尝试GetViewMatrix（）中的评论线。 这些将使围绕世界轴的相机位置旋转，以便相机一直在看世界的起源。 只有一个物体以屏幕上的世界来源为中心，它可以（令人困惑）看起来像对象正在旋转，而不是摄像机旋转。
在更改GetModelMatrix（）之前，将视图位置设置回2,3,4的固定值。 现在，在GetModelMatrix（）中评论一些行。 在运行程序之前尝试猜测效果。

(2)一群立方体
多维数据集数据结构中使用的纹理坐标已更改，以便每个面使用纹理的一部分。 您应该在v03_gleventlistener.java中检查此数据结构。

Rendering a 5x5 grid of cubes

public void render(GL3 gl) {
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

    Mat4 projectionMatrix = Mat4Transform.perspective(45, aspect);
    Mat4 viewMatrix = getViewMatrix();
    
    shader.use(gl);
    shader.setFloatArray(gl, "view", viewMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "projection", projectionMatrix.toFloatArrayForGLSL());
    
    gl.glActiveTexture(GL.GL_TEXTURE0);
    gl.glBindTexture(GL.GL_TEXTURE_2D, textureId1[0]);
  
    for (int i=-2; i<3; ++i) {
      for (int j=-2; j<3; ++j) {
        Mat4 modelMatrix = getModelMatrix(2f*i, 2f*j);
        Mat4 mvpMatrix = Mat4.multiply(projectionMatrix, Mat4.multiply(viewMatrix, modelMatrix));

        shader.setFloatArray(gl, "model", modelMatrix.toFloatArrayForGLSL());
        shader.setFloatArray(gl, "mvpMatrix", mvpMatrix.toFloatArrayForGLSL());

        gl.glBindVertexArray(vertexArrayId[0]);
        gl.glDrawElements(GL.GL_TRIANGLES, indices.length, GL.GL_UNSIGNED_INT, 0);
        gl.glBindVertexArray(0);
      }
    }
  }
    
  private Mat4 getModelMatrix(float i, float j) {
    double elapsedTime = getSeconds()-startTime;
    float angle = (float)(elapsedTime*50);
    Mat4 modelMatrix = new Mat4(1);    
    //modelMatrix = Mat4.multiply(modelMatrix, Mat4Transform.rotateAroundY(angle));
    modelMatrix = Mat4.multiply(modelMatrix, Mat4Transform.translate(i, 0, j));
    //modelMatrix = Mat4.multiply(modelMatrix, Mat4Transform.rotateAroundX(angle));
    modelMatrix = Mat4.multiply(modelMatrix, Mat4Transform.rotateAroundY(angle));
    return modelMatrix;
  }
  
  private Mat4 getViewMatrix() {
    double elapsedTime = getSeconds()-startTime;
    Vec3 pos = new Vec3(4,6,10);
    Mat4 viewMatrix = Mat4Transform.lookAt(pos, new Vec3(0,0,0), new Vec3(0,1,0));
    return viewMatrix;
  }

(3)更多的立方体
此示例显示了100个随机定位的立方体。该程序类似于v03.java，其中一个主要区别。 立方体位于随机位置，而不是正常网格的一部分。 每次渲染场景时，都必须生成相同的随机位置。 这是使用程序运行后一次创建的随机数的全局数组来完成的。

 public void render(GL3 gl) {
    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

    Mat4 projectionMatrix = Mat4Transform.perspective(45, aspect);
    Mat4 viewMatrix = getViewMatrix();
    
    shader.use(gl);
    shader.setFloatArray(gl, "view", viewMatrix.toFloatArrayForGLSL());
    shader.setFloatArray(gl, "projection", projectionMatrix.toFloatArrayForGLSL());
    
    gl.glActiveTexture(GL.GL_TEXTURE0);
    gl.glBindTexture(GL.GL_TEXTURE_2D, textureId1[0]);
  
    for (int i=0; i<100; ++i) {
      Mat4 modelMatrix = getModelMatrix(i);
      Mat4 mvpMatrix = Mat4.multiply(projectionMatrix, Mat4.multiply(viewMatrix, modelMatrix));
        
      shader.setFloatArray(gl, "model", modelMatrix.toFloatArrayForGLSL());
      shader.setFloatArray(gl, "mvpMatrix", mvpMatrix.toFloatArrayForGLSL());
      
      gl.glBindVertexArray(vertexArrayId[0]);
      gl.glDrawElements(GL.GL_TRIANGLES, indices.length, GL.GL_UNSIGNED_INT, 0);
      gl.glBindVertexArray(0);
    }
  }
the only KIrsTEN
关注
专栏目录
3D空间坐标到2D屏幕坐标
cangqiongxiaoye的博客
04-09 474
3D空间坐标到2D屏幕坐标
OpenGL显示3D立方体
krais_wk的博客
07-28 2146
OpenGL显示3D立方体 坐标系统 在上一章中，我们学会了如何通过变换矩阵变换所有顶点来发挥我们的优势。OpenGL 期望在每个顶点着色器运行后，所有我们希望可见的顶点都处于规范化的设备坐标中。即每个顶点的xyz坐标应在-1.0到1.0之间：此范围以外的坐标将不可见。我们通常做法是在我们自己确定的范围内（或空间）中指定坐标，并在顶点着色器中将这些坐标转换为规范化的设备坐标 （NDC）。然后，将这些NDC提供给光栅器以便将它们转换为屏幕上的 2D 坐标/像素。 将坐标转换为 NDC 通常是逐步完成的，我们将
3D空间中的点坐标转化为屏幕二维点坐标（二）
AhCola
11-11 7713
????原文地址：3D空间中的点坐标转化为屏幕二维点坐标（二）???? 上一节，简单的介绍了计算机时如何将三维世界中的点转化成屏幕上的二维点坐标的，知道了透视矩阵的作用。这一节内容，就是介绍其中的数学计算的过程。 坐标系与矩阵 在三维计算机图形学中，那些呈现在屏幕（画布canvas）上的每个点，都是由三维的点转化的，它们组成了屏幕上的图像。在前面的文章中，我介绍了透视矩阵，透视矩阵的作用就是将三维的点转化成二维的点，展现在屏幕上，也给大家讲解了透视投影矩阵的计算，所以本节内容 当然并不是再次计算透视投影矩阵
Unity3D教程：将3D坐标转成2D坐标的方法
苗伟业的专栏
04-15 6360
Unity3D教程：将3D坐标转成2D坐标的方法。3D坐标在Unity中称作World Space,2D坐标称作Screen Space, 是以pixel为基准，以iPad 1024 x 768（4:3）的解析度为例子： 左上角是 （0,0） 右下角是（1024,768） Unity3D教程：将3D坐标转成2D坐标的方法 功能制作：点击画面中的3D方块 然後在该方块的中心位置产生相
用纯C语言实现3D空间中的点坐标转化为屏幕二维点坐标，包含主视图、侧视图、俯视图、正等轴投影
Koma的主页
02-19 1491
要实现3D空间中的点坐标转换为屏幕二维点坐标，需要进行透视变换和投影变换。以下是一些基本的思路和示例代码，可以用于实现主视图、侧视图、俯视图、正等轴投影。
3d世界坐标转换到某个二维平面。
最新发布
weixin_44265800的博客
04-19 550
有个功能需要截取某个平面的点云数据，然后计算宽高。需要将3d点投影到二维平面上。
Solidworks二次开发-3D坐标转2D坐标
qq_43050689的博客
08-25 1357
solidworks坐标转换
3d立方体旋转
11-03
10. **视图投影**：在实际渲染中，还需要考虑视图和投影变换，将3D立方体的坐标转换到2D屏幕坐标，以便在屏幕上显示。 综上所述，3D立方体的旋转涉及到了数学、物理和计算机科学的多个领域。理解并掌握这些概念对于...
图形学实验-立方体线框模型透视投影
05-03
齐次坐标允许我们处理无穷远的点，而投影矩阵则可以将3D空间中的点转换为2D屏幕坐标。 投影矩阵通常包含透视除法（或称为透视切割），它会根据对象到视点的距离调整其大小。在视平面上，越远的点被分配的屏幕空间就...
OpenGL立方体在世界坐标系中_缩放_旋转_平移_顶点片源着色器_光照作用_棋盘纹理贴图
05-23
在“OpenGL立方体在世界坐标系中_缩放_旋转_平移_顶点片源着色器_光照作用_棋盘纹理贴图”这个主题中，我们将探讨一系列关键概念和技术，这些都是在3D渲染和游戏开发中不可或缺的。 1. **世界坐标系**：在OpenGL中...
将3D坐标转成2D坐标的方法2
08-08
2.用“tower”标签名称来区隔不同的3D物件 3.用此功能取得所点击的3D物件的x,y,z坐标（world space） 然后再透过camera.World
屏幕2D坐标转化为场景3D坐标
12-24
Name: ReadDepth Desc: 通过读取Z Buffer深度值将屏幕2D坐标转化为场景3D坐标 操作：点击鼠标左键，在标题栏上会显示深度值和转化后的场景3D坐标
Android应用源码OpenGL 3D立方体多纹理贴图.zip
12-04
在这个例子中，顶点着色器会将立方体的坐标从模型坐标系转换到设备坐标系。 4. **片段着色器**: 片段着色器在像素级别工作，负责生成最终的颜色。在3D立方体的多纹理贴图中，片段着色器会决定每个像素应该应用哪个...
UE4 3D坐标转2D坐标
playmaker的博客
05-12 1204
UE4 3D坐标转2D坐标 视角相机 ulocalplayer->playercontroller->cameramanager->POV struct FMatrix RotatorToMatrix(struct FRotator rotation) { float radPitch = rotation.Pitch * ((float)M_PI / 180.0f); float radYaw = rotation.Yaw * ((float)M_PI / 180.0f); flo
3D空间中的点坐标转化为屏幕二维点坐标（一）
AhCola
11-10 4583
每个人在进入计算机图形学的世界中，都有一个同样的困惑，三维世界中的三维坐标是如何被转换成屏幕上的二维坐标的，我如何在屏幕上找到一个点（二维点）对应三维世界中的点（三维点）呢？ 要理解其中的过程，对学习计算机图形学是非常重要的。这里，我假设你已经了解计算机图形学中一些基本的数学知识，例如向量和矩阵，也知道矩阵在图形变换中起到的作用。如果不清楚这些概念，或者想重温一下这些数学知识，可以看看我的其他文章。 三维世界中的坐标转换成二维世界中的坐标的这个转换过程，也可以看做矩阵的变换，这个变换矩阵将三维坐标转换成屏幕
三维坐标转换为二维坐标
snyl0926的博客
04-06 9298
三维坐标转换为二维坐标 最近做项目用到三维坐标转换为二维平面坐标的转换公式。看了网上的很多资料，都不太适用自己的项目。最后决定自己来推导。 具体问题描述 如下图所示，将二维平面上的三维坐标系O-X’Y’Z’转换为二维坐标系O-XY。 目的 可以在二维平面上绘制三维立体图。 ## 标题公式 假设在三维坐标系中有一点A(x’,y’,z’)，转换为二维坐标系中的A’(x,y)。 根据向量知识可得公式：...
opencv中3D点根据相机参数投影成2D点+solvePnP函数计算相机姿态+2D坐标到3D+相机参数calibration(标定与配准，求得深度彩色相机的内参与外参，再进行配准)
热门推荐
starDu
01-12 1万+
1.opencv中3D点根据相机参数投影成2D点，直接上代码： 输入：3D坐标+旋转，平移矩阵+相机内参（包括畸变矩阵） 输出：2D坐标 （旋转，平移：把三维点先变成相对于相机坐标系 投影函数：根据相机参数（包括畸变矩阵），把3D投影到2D平面） #include "opencv2/core/core.hpp" #include "opencv2/imgproc/imgproc.h
从世界坐标系到相机坐标系（3D物体到2D图像的转变）
点水穿石，不只是一种信念，还有一种无畏的勇气。
04-11 5099
．各种坐标系及其存在的原因： 要谈坐标系变换，那么坐标系有哪些呢？依次有:物体坐标系，世界坐标系，相机坐标系，投影坐标系以及屏幕坐标系.我要讨论的就是这些坐标系间的转换。 这些坐标系不是凭空而来，他们都是为了完成计算机3D图形学最最最基本的目标而出现.计算机3D图形学最最最基本的目标就是:将构建好的3D物体显示在2D屏幕坐标上.初看好像就是将最初的物体坐标系转换到屏幕坐标系就可以了呀，
将三维地理坐标转换到二维屏幕坐标
HW140701的博客
03-30 1万+
如何将三维地理坐标如（388691,4103865,4300）的（X,Y,Z）类型的坐标转化为在视口中能够被看见的地理坐标，在OpenGL中虽然可以转化，但是通过缩放之类的操作之后并没有成功，还是将图形或者点画在视口的范围之外，在屏幕视口中看不到。 在网上搜寻之后，得到如下的方法； 方法一：中心点配对法：即视图中心与地理空间中心点匹配，根据给定的地理坐标，计算该点与视野中心点的偏移和比例来进行...
CSS3 2D与3D变换详解：从坐标系到变换函数
3. 3D缩放（scale3d）：同理于2D缩放，但在3D空间中进行，例如`scale3d(x, y, z)`。 4. 3D视图（perspective）：通过设置`perspective(value)`，可以模拟观察者与元素之间的距离，创造出更真实的3D效果。 5. 3D...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值