24-透视投影算法

于 2023-12-06 18:30:02 发布
阅读量103 收藏
点赞数
分类专栏： 图形学 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25547755/article/details/134838385
版权

透视类

class Projection  // 透视投影
{
public:
    Point3 Eye;   // 视点
    double R;     // 视点球坐标
    double Phi;   // 
    double Theta; // 
    double D;     // 
    double K[8];  // 透视常数
public:
    Projection()
    {       
        R = 1000;
        D = 800;
        Phi = 90;
        Theta = 0;      // 世界坐标z轴正上方 看向原点
        InitialParameter();
    }
    ~Projection(){}

    void InitialParameter() // 初始化参数
    {
        K[0] = sin(PI * Theta / 180);
        K[1] = sin(PI * Phi / 180);
        K[2] = cos(PI * Theta / 180);
        K[3] = cos(PI * Phi / 180);
        K[4] = K[1] * K[2];
        K[5] = K[0] * K[1];
        K[6] = K[2] * K[3];
        K[7] = K[0] * K[3];
        Eye  = Point3(R * K[5], R * K[5], R * K[4]); // 设置视点
    }

    void SetEye(double r, double phi, double theta)   // 设置视点
    {
        R = r;
        Phi = phi;
        Theta = theta;
        InitialParameter();
    }

    Point3 GetEye()
    {
        return Eye;
    }

    Point2 PerspectiveProjection2(Point3 worldPoint) // 二维透视投影
    {
        Point3 viewPoint;  // 观察坐标系
        viewPoint.x =  K[2] * worldPoint.x - K[0] * worldPoint.z;
        viewPoint.y = -K[7] * worldPoint.x + K[1] * worldPoint.y - K[6] * worldPoint.z;
        viewPoint.z = -K[5] * worldPoint.x - K[3] * worldPoint.y - K[4] * worldPoint.z + R;

        Point2 screenPoint; // 屏幕坐标
        screenPoint.x = D * viewPoint.x / viewPoint.z;
        screenPoint.y = D * viewPoint.y / viewPoint.z;

        return screenPoint;
    }
};

完整代码

// 24-透视投影算法
// 参考 https://www.bilibili.com/video/BV1Ne4y1m7MF

#define UNICODE
#include <Windows.h>
#include <Windowsx.h>
#include <math.h>
#define WINDOW_TEXT L"24-透视投影算法"
#define ROUND(d) int(floor(d)+0.5)  // 四舍五入
#define PI        3.1415926

struct Point2  // 二维点
{
    double x;
    double y;
    double w;  // 齐次坐标
    Point2() :x(0), y(0), w(0) {}
    Point2(double x, double y) :x(x), y(y), w(0) {}
};

struct Point3  // 三维点
{
    double x;
    double y;
    double z;
    double w;  // 齐次坐标
    Point3() :x(0), y(0), z(0), w(0) {}
    Point3(double x, double y, double z) :x(x), y(y), z(z), w(0) {}
};

struct Face        // 面
{
    int ptIndex[4] = { 0,0,0,0 }; // 面顶点索引
    Face() {};
    ~Face() {};
};

class Transform3
{
public:
    Point3* _P;          // 顶点数组
    int     _ptNumber;   // 顶点数量
    double  _M[4][4];    // 变换矩阵
public:
    Transform3() :_P(NULL), _ptNumber(0)
    {
        memset(_M, 0, sizeof(_M));
    };
    ~Transform3() {};

    void MultiplyMatrix()  //矩阵相乘
    {
        Point3* PTemp = new Point3[_ptNumber];
        for (int i = 0; i < _ptNumber; i++)
        {
            PTemp[i] = _P[i];
        }
        for (int i = 0; i < _ptNumber; i++)
        {
            _P[i].x = _M[0][0] * PTemp[i].x + _M[0][1] * PTemp[i].y + _M[0][2] * PTemp[i].z + _M[3][0]; // * PTemp[i].w
            _P[i].y = _M[1][0] * PTemp[i].x + _M[1][1] * PTemp[i].y + _M[1][2] * PTemp[i].z + _M[3][1]; // * PTemp[i].w
            _P[i].z = _M[2][0] * PTemp[i].x + _M[2][1] * PTemp[i].y + _M[2][2] * PTemp[i].z + _M[3][2]; // * PTemp[i].w
            _P[i].w = _M[3][0] * PTemp[i].x + _M[3][1] * PTemp[i].y + _M[3][2] * PTemp[i].z + _M[3][3]; // * PTemp[i].w
        }

        delete[]PTemp;
    }

    void SetMatrix(Point3* P, int ptNumber) //顶点数组初始化
    {
        _P = P;
        _ptNumber = ptNumber;
    }
    void Identity()
    {
        _M[0][0] = 1.0, _M[0][1] = 0.0, _M[0][2] = 0.0, _M[0][3] = 0.0;
        _M[1][0] = 0.0, _M[1][1] = 1.0, _M[1][2] = 0.0, _M[1][3] = 0.0;
        _M[2][0] = 0.0, _M[2][1] = 0.0, _M[2][2] = 1.0, _M[2][3] = 0.0;
        _M[3][0] = 0.0, _M[3][1] = 0.0, _M[3][2] = 0.0, _M[3][3] = 1.0;
    }

    void Translate(double tx, double ty, double tz)//平移变换
    {
        Identity();
        _M[3][0] = tx;
        _M[3][1] = ty;
        _M[3][2] = tz;
        MultiplyMatrix();
    }

    void Scale(double sx, double sy, double sz)//缩放变换
    {
        Identity();
        _M[0][0] = sx;
        _M[1][1] = sy;
        _M[2][2] = sz;
        MultiplyMatrix();
    }  

    void RotateX(double beta)//绕X轴旋转变换
    {
        Identity();
        beta = beta * PI / 180;
        _M[1][1] = cos(beta), _M[1][2] = -sin(beta);
        _M[2][1] = sin(beta), _M[2][2] = cos(beta);
        MultiplyMatrix();
    }

    void  RotateY(double beta)//绕Y轴旋转变换
    {
        Identity();
        beta = beta * PI / 180;
        _M[0][0] = cos(beta), _M[0][2] = sin(beta);
        _M[2][0] = -sin(beta), _M[2][2] = cos(beta);
        MultiplyMatrix();
    }

};

class Projection  // 透视投影
{
public:
    Point3 Eye;   // 视点
    double R;     // 视点球坐标
    double Phi;   // 
    double Theta; // 
    double D;     // 
    double K[8];  // 透视常数
public:
    Projection()
    {       
        R = 1000;
        D = 800;
        Phi = 90;
        Theta = 0;      // 世界坐标z轴正上方 看向原点
        InitialParameter();
    }
    ~Projection(){}

    void InitialParameter() // 初始化参数
    {
        K[0] = sin(PI * Theta / 180);
        K[1] = sin(PI * Phi / 180);
        K[2] = cos(PI * Theta / 180);
        K[3] = cos(PI * Phi / 180);
        K[4] = K[1] * K[2];
        K[5] = K[0] * K[1];
        K[6] = K[2] * K[3];
        K[7] = K[0] * K[3];
        Eye  = Point3(R * K[5], R * K[5], R * K[4]); // 设置视点
    }

    void SetEye(double r, double phi, double theta)   // 设置视点
    {
        R = r;
        Phi = phi;
        Theta = theta;
        InitialParameter();
    }

    Point3 GetEye()
    {
        return Eye;
    }

    Point2 PerspectiveProjection2(Point3 worldPoint) // 二维透视投影
    {
        Point3 viewPoint;  // 观察坐标系
        viewPoint.x =  K[2] * worldPoint.x - K[0] * worldPoint.z;
        viewPoint.y = -K[7] * worldPoint.x + K[1] * worldPoint.y - K[6] * worldPoint.z;
        viewPoint.z = -K[5] * worldPoint.x - K[3] * worldPoint.y - K[4] * worldPoint.z + R;

        Point2 screenPoint; // 屏幕坐标
        screenPoint.x = D * viewPoint.x / viewPoint.z;
        screenPoint.y = D * viewPoint.y / viewPoint.z;

        return screenPoint;
    }
};


class Cube        // 立方体
{
public:
    Point3      _V[8]; // 点表
    Face        _F[6]; // 面表
    Projection  _projection; // 透视
public:
    Cube() {};
    ~Cube() {};

    void ReadVertex() // 读取点表
    {
        _V[0].x = 0; _V[0].y = 0; _V[0].z = 0;
        _V[1].x = 1; _V[1].y = 0; _V[1].z = 0;
        _V[2].x = 1; _V[2].y = 1; _V[2].z = 0;
        _V[3].x = 0; _V[3].y = 1; _V[3].z = 0;
        _V[4].x = 0; _V[4].y = 0; _V[4].z = 1;
        _V[5].x = 1; _V[5].y = 0; _V[5].z = 1;
        _V[6].x = 1; _V[6].y = 1; _V[6].z = 1;
        _V[7].x = 0; _V[7].y = 1; _V[7].z = 1;

    }
    void ReadFace()  // 读取面表
    {
        _F[0].ptIndex[0] = 0; _F[0].ptIndex[1] = 4; _F[0].ptIndex[2] = 7; _F[0].ptIndex[3] = 3; // 左
        _F[1].ptIndex[0] = 1; _F[1].ptIndex[1] = 2; _F[1].ptIndex[2] = 6; _F[1].ptIndex[3] = 5; // 右
        _F[2].ptIndex[0] = 0; _F[2].ptIndex[1] = 1; _F[2].ptIndex[2] = 5; _F[2].ptIndex[3] = 4; // 底
        _F[3].ptIndex[0] = 2; _F[3].ptIndex[1] = 3; _F[3].ptIndex[2] = 7; _F[3].ptIndex[3] = 6; // 顶
        _F[4].ptIndex[0] = 0; _F[4].ptIndex[1] = 3; _F[4].ptIndex[2] = 2; _F[4].ptIndex[3] = 1; // 后
        _F[5].ptIndex[0] = 4; _F[5].ptIndex[1] = 5; _F[5].ptIndex[2] = 6; _F[5].ptIndex[3] = 7; // 前
    }

    void Draw(HDC hdc)
    {
        Point2 screenPoint[4];                             // 二维点

        for (int nFace = 0; nFace < 6; nFace++)            // 面循环
        {

            for (int nVertex = 0; nVertex < 4; nVertex++)  // 点循环
            {
                int vertex = _F[nFace].ptIndex[nVertex];

                screenPoint[nVertex] = _projection.PerspectiveProjection2(_V[vertex]);
            }

            MoveToEx(hdc, ROUND(screenPoint[0].x), ROUND(screenPoint[0].y), NULL); // 绘制多边形            
            LineTo(hdc, ROUND(screenPoint[1].x), ROUND(screenPoint[1].y));
            LineTo(hdc, ROUND(screenPoint[2].x), ROUND(screenPoint[2].y));
            LineTo(hdc, ROUND(screenPoint[3].x), ROUND(screenPoint[3].y));
            LineTo(hdc, ROUND(screenPoint[0].x), ROUND(screenPoint[0].y));
        }

    }
};

static bool     m_Play = false;
static wchar_t* m_str = L"左键 - 旋转 | 暂停";

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    RECT rect;
    static double alpha;
    static double beta;


    switch (uMsg)
    {
    case WM_TIMER:
        alpha += 1;
        beta += 1;
        InvalidateRect(hwnd, NULL, FALSE);
        return 0;

    case WM_LBUTTONDOWN:
        m_Play = !m_Play;
        if (m_Play)
        {
            SetTimer(hwnd, 0, 0, NULL);
        }
        else
        {
            KillTimer(hwnd, 0);
        }
        return 0;

    case WM_PAINT:
    {
        hdc = BeginPaint(hwnd, &ps);
        GetClientRect(hwnd, &rect);

        SetMapMode(hdc, MM_ANISOTROPIC);
        SetWindowExtEx(hdc, rect.right, rect.bottom, NULL);
        SetViewportExtEx(hdc, rect.right, -rect.bottom, NULL);
        SetViewportOrgEx(hdc, rect.right / 2, rect.bottom / 2, NULL);

        // 内存DC
        HDC     memDC = CreateCompatibleDC(hdc);                               // 创建兼容DC 画板
        HBITMAP newBitmap = CreateCompatibleBitmap(hdc, rect.right, rect.bottom);  // 创建画布
        HGDIOBJ oldBitmap = SelectObject(memDC, newBitmap);                    // 将画布选入画板
        FillRect(memDC, &rect, (HBRUSH)(COLOR_WINDOW + 1));
        DrawText(memDC, m_str, wcslen(m_str), &rect, NULL);

        SetMapMode(memDC, MM_ANISOTROPIC);
        SetWindowExtEx(memDC, rect.right, rect.bottom, NULL);
        SetViewportExtEx(memDC, rect.right, -rect.bottom, NULL);
        SetViewportOrgEx(memDC, rect.right / 2, rect.bottom / 2, NULL);


        // 绘制图形
        {
            static Cube cube;
            static Transform3 transform;

            cube.ReadVertex();
            cube.ReadFace();

            transform.SetMatrix(cube._V, 8);  // 设置顶点

            double scale = 300;

            transform.Scale(scale, scale, scale);                     // 放大

            transform.Translate(-scale / 2, -scale / 2, -scale / 2);    // 平移
            transform.RotateX(alpha);
            transform.RotateY(beta);

            cube.Draw(memDC);

        }

        // 内存dc复制到设备
        BitBlt(hdc, ROUND(-rect.right / 2), ROUND(-rect.bottom / 2), rect.right, rect.bottom, memDC, ROUND(-rect.right / 2), ROUND(-rect.bottom / 2), SRCCOPY);

        SelectObject(memDC, oldBitmap);

        DeleteObject(newBitmap);
        DeleteDC(memDC);

        EndPaint(hwnd, &ps);
    }
    return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;

    }
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int nCmdShow)
{
    // Register the window class.
    const wchar_t CLASS_NAME[] = L"CAG";
    WNDCLASS wc = { };

    wc.style = CS_HREDRAW | CS_VREDRAW; // 重新绘制整个工作区
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    RegisterClass(&wc);

    HWND hwnd = CreateWindowEx(
        0,                              // Optional window styles.
        CLASS_NAME,                     // Window class
        WINDOW_TEXT,                    // Window text
        WS_OVERLAPPEDWINDOW,            // Window style

        // Size and position
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

        NULL,       // Parent window    
        NULL,       // Menu
        hInstance,  // Instance handle
        NULL        // Additional application data
    );

    if (hwnd == NULL)
    {
        return 0;
    }
    ShowWindow(hwnd, nCmdShow);
    MSG msg = { };
    while (GetMessage(&msg, NULL, 0, 0) > 0)
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return 0;
}

透视投影矩阵推导

透视投影三要素:视点、屏幕、物体

世界坐标原点平移至观察坐标系原点

绕y轴旋转

绕x轴旋转

仿射变换，（从右手系变为左手洗）新坐标系与观察坐标系重合

世界坐标右手系统，屏幕坐标左手系，观察坐标左系

原点平移到视点的矩阵

绕y轴旋转

变换矩阵

HelloRevit
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
透视投影的原理和实现
Goncely的专栏
03-19 2万+
透视投影的原理和实现by Goncely 摘  要：透视投影是3D渲染的基本概念，也是3D程序设计的基础。掌握透视投影的原理对于深入理解其他3D渲染管线具有重要作用。本文详细介绍了透视投影的原理和算法实现，包括透视投影的标准模型、一般模型和屏幕坐标变换等，并通过VC实现了一个演示程序。1 概述在计算机三维图像中，投影可
基于FPGA的透视投影变换算法的设计与实现
06-01
基于FPGA的透视投影变换算法的设计与实现.
透视投影
SlimApp
12-12 1340
透视投影最显著的特征就是透视缩短，物体距离照相机越远，它在最终图像中看上去就越小。这是因为透视投影的视景体可以看成是一个金字塔的平截头体（顶部被一个平行于底面的平面截除）。位于视景体之内的物体被投影到金字塔的顶点，也就是照相机或观察点的位置。靠近观察点的物体看上去更大一些，因为和远处的物体相比，它们占据了视景体中相对较大的区域。这种投影方法常用于动画、视觉模拟以及其他要求某种程度的现实感的应用领域
投影算法
lzj0470的专栏
11-23 1566
<br />先标记一下，迟点在补充内容与实现。
透视投影的矩阵计算
whr12的博客
12-11 2904
整理计算机图形学中，3D物体从摄像机坐标转化为规范化投影坐标的求解过程
论文研究 - 支持移动设备室内定位的透视投影算法
05-31
通过将特征点与用户图像的特征点进行匹配，我们可以通过从用户图像中获取六个或更多像素坐标并使用透视投影公式求解解决方案来获得用户在室内地图上的位置。 实验结果表明，仅使用软件即可在室内环境中更准确地获得...
立方体线框模型透视投影
10-15
(1) 在屏幕中心建立三维坐标系Oxyz，x轴水平向右，y轴铅直向上，z轴 垂直于屏幕指向观察者 (2) 建立以三维...的顶点坐标 (4) 屏幕上绘制立方体线框模型的二维正交投影图 (5) 屏幕上绘制立方体线框模型的二维透视投影图
wendan.rar_透视投影
09-23
“wendan.docx”文件可能包含详细的算法描述、示例代码或案例分析，帮助读者深入理解和实现透视投影。通过学习和实践这些内容，开发者可以更好地创建出具有深度感和真实感的三维图形应用程序，如游戏、虚拟现实环境...
易语言-易语言图像透视算法
06-29
2. **平行透视法**：又称为一点透视或线性透视，是最常见的透视理论，适用于描绘物体在平面上的投影。它假设所有平行线在远处都会汇聚于一个消失点，使得图像产生深度感。在建筑和室内设计的图像渲染中，平行透视法...
计算机图形学透视投影变换实验报告
04-19
在本实验中，我们将深入探讨这一主题，并通过VC6++ MFC编程实现透视投影算法。 首先，实验的目标在于理解和掌握虚拟机的使用，包括VMware Workstation Pro以及Windows XP系统的安装和配置。此外，实验还要求我们...
投影算法：投影算法-matlab开发
05-30
投影算法是一种参数估计方法，用于估计传递函数的参数参考：Astrom 的自适应控制
透视图算法.rar
06-02
在世界坐标系中定义一个立方体（由6个面组成），并给定观察点在世界坐标系中的位置(a,b,c)以及观察坐标系的方位角θ，俯仰角φ和姿态角α，另外再给定投影面离观察点的距离D，在屏幕上画出立方体的透视投影图形。
连续投影算法
04-19
连 续 投 影 算 法(SPA)是 一 种 使 矢 量 空 间 共 线 性最小化的前向变量选择算法， 它的优势在于提取全波段的几个特征波长， 能够消除原始光谱矩阵中冗余的信息，可用于光谱特征波长的筛选。 近年来 ，国内外学者在利用光谱分析技术检测作物和食品中某些重要成分的含量时利用了连续投影算法作有效波长的选取。
计算机图形学之投影算法（ppt）
06-04
对三维图形的建立，显示介绍的很详细，特别是显示流程图都有
计算机图形学 透视图算法
06-04
计算机图形学 三维一点透视算法 基于vc++6.0
投影的一些算法
ZHANGHUI3239619的专栏
12-07 2972
地面分辨率= [cos(纬度 * pi/180)*2*pi*地球长半径(米)]/(256 * 2level 像素) 地图比例尺 = 1: 地面分辨率(米/像素)×屏幕分辨率(像素/英寸)/ 0.0254(米/英寸)
简单的透视投影
linuxheik的专栏
11-30 1237
简单的说，视景体裁剪发生在透视投影之后，透视除法之前，所以不会发生你说的错误。 另外纠正一个说法，透视投影是把向量投影到裁剪空间，而不是所谓的“投影平面上”。 复杂的说： 如果显卡是你做的，你想怎么裁剪都可以，在透视除法之前的任何阶段裁剪都可以，用普通高中生的解析几何都行。 但是，有一种公认比较简单的裁剪方法： 设原有向量，投影矩阵， 投影后为，此时
常用的地图投影算法
weixin_34360651的博客
05-19 1020
1 经纬度坐标 1.1 纬线 纬线是地球球面上的一个一个的同地球自转轴垂直的圆。赤道处最大。 1.2 经线 连接南极点和北极点的大圆弧。 1.3 经纬度坐标 赤道和0度经线相交的地方是坐标原点。0度经线在英国伦敦的格林尼治天文台，这条经线向东就是东经，向西就是西经，然后180度之后，它们相遇。 可见经纬度是球面坐标，我们要在平面地图上显示一个点的话，需要投影到平面坐标，因此才有...
光线投影算法
eCode代码加工厂
12-08 9058
光线投射算法是体绘制中的经典算法，由于其绘制出的图像质量最高，因而被广泛研究与应用。
透视投影算法openGL
最新发布
06-27
透视投影是计算机图形学中用于创建三维空间到二维平面上真实透视效果的一种算法。在OpenGL中，它是光照和渲染过程中关键的一环，常用于游戏、虚拟现实等场景。以下是基本的透视投影算法在OpenGL中的实现： 1. **视口和投影矩阵**：首先，你需要设置一个视口，这定义了渲染的目标区域。然后，创建一个投影矩阵，根据相机的位置、视角和裁剪平面（近/远平面）来确定物体在屏幕上的大小和形状。 2. **正交投影和透视投影**：正交投影保持物体在每个方向上的比例相同，常用于2D游戏或布局设计；透视投影则模拟人眼的观察角度，远处的物体看起来更小，给人一种深度感。 3. **模型-视图-投影(MVP)矩阵**：将模型矩阵（物体的位置、旋转和缩放）与视图矩阵（摄像机位置和方向）相乘，再与投影矩阵相乘，得到MVP矩阵，这一步是将三维物体转换为屏幕坐标系的关键。 4. **纹理和颜色贴图**：在投影后，可以应用纹理和颜色信息，使图像更具细节和真实感。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值