17-二维图形几何变换算法

已于 2023-12-05 12:41:20 修改
阅读量50 收藏
点赞数
分类专栏： 图形学 文章标签： 算法
于 2023-12-05 10:23:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25547755/article/details/134800153
版权

参考：https://www.bilibili.com/video/BV12W4y1v75

原始图形

        // 窗格坐标点
        _P[ 0] = Point2(-4,-4);
        _P[ 1] = Point2(-2,-4);
        _P[ 2] = Point2( 0,-4);
        _P[ 3] = Point2( 2,-4);
        _P[ 4] = Point2( 4,-4);
        _P[ 5] = Point2(-2,-3);
        _P[ 6] = Point2( 2,-3);
        _P[ 7] = Point2(-4,-2);
        _P[ 8] = Point2(-3,-2);
        _P[ 9] = Point2( 3,-2);
        _P[10] = Point2( 4,-2);
        _P[11] = Point2(-1.5, -1.5);
        _P[12] = Point2(0, -1.5);
        _P[13] = Point2(1.5, -1.5);
        _P[14] = Point2(-4, 0);
        _P[15] = Point2(-1.5, 0);
        _P[16] = Point2(1.5, 0);
        _P[17] = Point2( 4,  0);
        _P[18] = Point2(-1.5, 1.5);
        _P[19] = Point2(0, 1.5);
        _P[20] = Point2(1.5, 1.5);
        _P[21] = Point2(-4, 2);
        _P[22] = Point2(-3, 2);
        _P[23] = Point2(3, 2);
        _P[24] = Point2(4,2);
        _P[25] = Point2(-2, 3);
        _P[26] = Point2(2, 3);
        _P[27] = Point2(-4, 4);
        _P[28] = Point2(-2,  4);
        _P[29] = Point2(0,  4);
        _P[30] = Point2(2,  4);
        _P[31] = Point2(4, 4);

平移变换

比例变换

旋转变换

反射变换

错切变换

复合变换

矩阵操作

class Transform2
{ 
private:
    double  _T[3][3];  // 变换矩阵
    Point2* _P;        // 点
    int     _ptNumber; // 顶点个数
public:
   
    void SetMatrix(Point2* p, int ptNumber)   // 设置二维顶点数组
    {
        this->_P = p;
        this->_ptNumber = ptNumber;
    }

    void Identity()  // 单位矩阵
    {
        _T[0][0] = 1.0; _T[0][1] = 0.0; _T[0][2] = 0.0;
        _T[1][0] = 0.0; _T[1][1] = 1.0; _T[1][2] = 0.0;
        _T[2][0] = 0.0; _T[2][1] = 0.0; _T[2][2] = 1.0;

    }

    void Translate(double tx,double ty) // 平移
    {
        Identity();
        _T[2][0] = tx;
        _T[2][1] = ty;
        MultiplyMatrix();

    }

    void Scale(double sx,double sy)    // 缩放
    {
        Identity();
        _T[0][0] = sx;
        _T[1][1] = sy;
        MultiplyMatrix();

    }

    void Scale(double sx, double sy,Point2 p) // 相对于点缩放
    {

        Translate(-p.x,-p.y); // 移至坐标原点
        Scale(sx, sy);
        Translate(p.x,p.y);   // 移回

    }

    void Rotate(double beta) //旋转
    {
        Identity();
        double rad = beta * PI / 180;
        _T[0][0] =  cos(rad); _T[0][1] =  sin(rad);
        _T[1][0] = -sin(rad); _T[1][1] =  cos(rad);
        MultiplyMatrix();
    }

    void Rotate(double beta , Point2 p) //相对于点旋转
    {
        Translate(-p.x, -p.y);
        Rotate(beta);
        Translate(p.x, p.y);

    }

    void ReflectOry() // 原点反射
    {
        Identity();
        _T[0][0] = -1;
        _T[1][1] = -1;
        MultiplyMatrix();
    }

    void ReflectX() // X轴反射
    {
        Identity();
        _T[0][0] =  1;
        _T[1][1] = -1;
        MultiplyMatrix();

    }

    void ReflectY() // Y轴反射
    {
        Identity();
        _T[0][0] =  -1;
        _T[1][1] =   1;
        MultiplyMatrix();

    }

    void Shear(double b,double c)  // 错切
    {
        Identity();
        _T[0][0] = b;
        _T[1][1] = c;
        MultiplyMatrix();
    }

    void MultiplyMatrix()    // 矩阵相乘
    {
        Point2* pTemp = new Point2[_ptNumber];

        for (int i = 0; i < _ptNumber; i++)
        {
            pTemp[i] = _P[i];
        }

        for (int i = 0; i < _ptNumber; i++)
        {
            _P[i].x = pTemp[i].x * _T[0][0] + pTemp[i].y * _T[1][0] + pTemp[i].w * _T[2][0];
            _P[i].y = pTemp[i].x * _T[0][1] + pTemp[i].y * _T[1][1] + pTemp[i].w * _T[2][1];
            _P[i].w = pTemp[i].x * _T[0][2] + pTemp[i].y * _T[1][2] + pTemp[i].w * _T[2][2];
        }
        delete[] pTemp;
    }
};

完整代码

// 16-二维图形几何变换算法
// 参考 https://www.bilibili.com/video/BV12W4y1v75a

#define UNICODE
#include <Windows.h>
#include <Windowsx.h>
#include <math.h>
#define WINDOW_TEXT L"16-二维图形几何变换算法"
#define ROUND(d) int(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) {}
    Point2(double x, double y,double w) :x(x), y(y), w(w) {}
};

class Transform2
{ 
private:
    double  _T[3][3];  // 变换矩阵
    Point2* _P;        // 点
    int     _ptNumber; // 顶点个数
public:
   
    void SetMatrix(Point2* p, int ptNumber)   // 设置二维顶点数组
    {
        this->_P = p;
        this->_ptNumber = ptNumber;
    }

    void Identity()  // 单位矩阵
    {
        _T[0][0] = 1.0; _T[0][1] = 0.0; _T[0][2] = 0.0;
        _T[1][0] = 0.0; _T[1][1] = 1.0; _T[1][2] = 0.0;
        _T[2][0] = 0.0; _T[2][1] = 0.0; _T[2][2] = 1.0;

    }

    void Translate(double tx,double ty) // 平移
    {
        Identity();
        _T[2][0] = tx;
        _T[2][1] = ty;
        MultiplyMatrix();

    }

    void Scale(double sx,double sy)    // 缩放
    {
        Identity();
        _T[0][0] = sx;
        _T[1][1] = sy;
        MultiplyMatrix();

    }

    void Scale(double sx, double sy,Point2 p) // 相对于点缩放
    {

        Translate(-p.x,-p.y); // 移至坐标原点
        Scale(sx, sy);
        Translate(p.x,p.y);   // 移回

    }

    void Rotate(double beta) //旋转
    {
        Identity();
        double rad = beta * PI / 180;
        _T[0][0] =  cos(rad); _T[0][1] =  sin(rad);
        _T[1][0] = -sin(rad); _T[1][1] =  cos(rad);
        MultiplyMatrix();
    }

    void Rotate(double beta , Point2 p) //相对于点旋转
    {
        Translate(-p.x, -p.y);
        Rotate(beta);
        Translate(p.x, p.y);

    }

    void ReflectOry() // 原点反射
    {
        Identity();
        _T[0][0] = -1;
        _T[1][1] = -1;
        MultiplyMatrix();
    }

    void ReflectX() // X轴反射
    {
        Identity();
        _T[0][0] =  1;
        _T[1][1] = -1;
        MultiplyMatrix();

    }

    void ReflectY() // Y轴反射
    {
        Identity();
        _T[0][0] =  -1;
        _T[1][1] =   1;
        MultiplyMatrix();

    }

    void Shear(double b,double c)  // 错切
    {
        Identity();
        _T[0][0] = b;
        _T[1][1] = c;
        MultiplyMatrix();
    }

    void MultiplyMatrix()    // 矩阵相乘
    {
        Point2* pTemp = new Point2[_ptNumber];

        for (int i = 0; i < _ptNumber; i++)
        {
            pTemp[i] = _P[i];
        }

        for (int i = 0; i < _ptNumber; i++)
        {
            _P[i].x = pTemp[i].x * _T[0][0] + pTemp[i].y * _T[1][0] + pTemp[i].w * _T[2][0];
            _P[i].y = pTemp[i].x * _T[0][1] + pTemp[i].y * _T[1][1] + pTemp[i].w * _T[2][1];
            _P[i].w = pTemp[i].x * _T[0][2] + pTemp[i].y * _T[1][2] + pTemp[i].w * _T[2][2];
        }
        delete[] pTemp;
    }
};

class  ClassicaPane
{
public:
    Point2 _P[32]; // 窗格顶点
public:
    ClassicaPane()
    {
        _P[ 0] = Point2(-4,-4);
        _P[ 1] = Point2(-2,-4);
        _P[ 2] = Point2( 0,-4);
        _P[ 3] = Point2( 2,-4);
        _P[ 4] = Point2( 4,-4);
        _P[ 5] = Point2(-2,-3);
        _P[ 6] = Point2( 2,-3);
        _P[ 7] = Point2(-4,-2);
        _P[ 8] = Point2(-3,-2);
        _P[ 9] = Point2( 3,-2);
        _P[10] = Point2( 4,-2);
        _P[11] = Point2(-1.5, -1.5);
        _P[12] = Point2(0, -1.5);
        _P[13] = Point2(1.5, -1.5);
        _P[14] = Point2(-4, 0);
        _P[15] = Point2(-1.5, 0);
        _P[16] = Point2(1.5, 0);
        _P[17] = Point2( 4,  0);
        _P[18] = Point2(-1.5, 1.5);
        _P[19] = Point2(0, 1.5);
        _P[20] = Point2(1.5, 1.5);
        _P[21] = Point2(-4, 2);
        _P[22] = Point2(-3, 2);
        _P[23] = Point2(3, 2);
        _P[24] = Point2(4,2);
        _P[25] = Point2(-2, 3);
        _P[26] = Point2(2, 3);
        _P[27] = Point2(-4, 4);
        _P[28] = Point2(-2,  4);
        _P[29] = Point2(0,  4);
        _P[30] = Point2(2,  4);
        _P[31] = Point2(4, 4);       

    };
    ~ ClassicaPane() {};   

    void Draw(HDC hdc)
    {

        MoveToEx(hdc,ROUND(_P[0].x), ROUND(_P[0].y),NULL);
        LineTo(hdc, ROUND(_P[4].x), ROUND(_P[4].y));
        LineTo(hdc, ROUND(_P[31].x), ROUND(_P[31].y));
        LineTo(hdc, ROUND(_P[27].x), ROUND(_P[27].y));
        LineTo(hdc, ROUND(_P[0].x), ROUND(_P[0].y));

        MoveToEx(hdc, ROUND(_P[5].x), ROUND(_P[5].y), NULL);
        LineTo(hdc, ROUND(_P[ 6].x), ROUND(_P[ 6].y));
        LineTo(hdc, ROUND(_P[ 9].x), ROUND(_P[ 9].y));
        LineTo(hdc, ROUND(_P[23].x), ROUND(_P[23].y));
        LineTo(hdc, ROUND(_P[26].x), ROUND(_P[26].y));
        LineTo(hdc, ROUND(_P[25].x), ROUND(_P[25].y));
        LineTo(hdc, ROUND(_P[22].x), ROUND(_P[22].y));
        LineTo(hdc, ROUND(_P[ 8].x), ROUND(_P[ 8].y));
        LineTo(hdc, ROUND(_P[ 5].x), ROUND(_P[ 5].y));
      
      
        MoveToEx(hdc, ROUND(_P[11].x), ROUND(_P[11].y), NULL);
        LineTo(hdc, ROUND(_P[13].x), ROUND(_P[13].y));
        LineTo(hdc, ROUND(_P[20].x), ROUND(_P[20].y));
        LineTo(hdc, ROUND(_P[18].x), ROUND(_P[18].y));
        LineTo(hdc, ROUND(_P[11].x), ROUND(_P[11].y));

        MoveToEx(hdc, ROUND(_P[7].x), ROUND(_P[7].y), NULL);
        LineTo(hdc, ROUND(_P[8].x), ROUND(_P[8].y));

        MoveToEx(hdc, ROUND(_P[1].x), ROUND(_P[1].y), NULL);
        LineTo(hdc, ROUND(_P[5].x), ROUND(_P[5].y));

        MoveToEx(hdc, ROUND(_P[2].x), ROUND(_P[2].y), NULL);
        LineTo(hdc, ROUND(_P[12].x), ROUND(_P[12].y));


        MoveToEx(hdc, ROUND(_P[3].x), ROUND(_P[3].y), NULL);
        LineTo(hdc, ROUND(_P[6].x), ROUND(_P[6].y));

        MoveToEx(hdc, ROUND(_P[10].x), ROUND(_P[10].y), NULL);
        LineTo(hdc, ROUND(_P[9].x), ROUND(_P[9].y));

        MoveToEx(hdc, ROUND(_P[17].x), ROUND(_P[17].y), NULL);
        LineTo(hdc, ROUND(_P[16].x), ROUND(_P[16].y));

        MoveToEx(hdc, ROUND(_P[14].x), ROUND(_P[14].y), NULL);
        LineTo(hdc, ROUND(_P[15].x), ROUND(_P[15].y));


        MoveToEx(hdc, ROUND(_P[23].x), ROUND(_P[23].y), NULL);
        LineTo(hdc, ROUND(_P[24].x), ROUND(_P[24].y));

        MoveToEx(hdc, ROUND(_P[26].x), ROUND(_P[26].y), NULL);
        LineTo(hdc, ROUND(_P[30].x), ROUND(_P[30].y));

        MoveToEx(hdc, ROUND(_P[19].x), ROUND(_P[19].y), NULL);
        LineTo(hdc, ROUND(_P[29].x), ROUND(_P[29].y));

        MoveToEx(hdc, ROUND(_P[25].x), ROUND(_P[25].y), NULL);
        LineTo(hdc, ROUND(_P[28].x), ROUND(_P[28].y));
       
        MoveToEx(hdc, ROUND(_P[21].x), ROUND(_P[21].y), NULL);
        LineTo(hdc, ROUND(_P[22].x), ROUND(_P[22].y));
        /*
         ... ...

        */
    }
};

static bool m_Play = false;
static int  m_Angle = 0;

LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    RECT rc;
    switch (uMsg)
    {
    case WM_TIMER:
        m_Angle++;
        InvalidateRect(hwnd, NULL, FALSE);
        return 0;

    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;

    case WM_LBUTTONDOWN:  

        m_Play = !m_Play;
        if (m_Play)
        {
            // 产生 WM_TIMER 消息
            SetTimer(hwnd, 0, 10, NULL);
        }
        else
        {
            // 销毁 WM_TIMER 消息
            KillTimer(hwnd, 0);
        }
        return 0;

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

        // 内存DC
        HDC     memDC = CreateCompatibleDC(hdc);                               // 创建兼容DC 画板
        HBITMAP newBitmap = CreateCompatibleBitmap(hdc, rc.right, rc.bottom);  // 创建画布
        HGDIOBJ oldBitmap = SelectObject(memDC, newBitmap);                    // 将画布选入画板
        FillRect(memDC, &rc, (HBRUSH)(COLOR_WINDOW + 1));
        DrawText(memDC, L"单击左键旋转图形", wcslen(L"单击左键开始动画"), &rc, NULL);

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

        // 绘制图形
        {
            ClassicaPane pane;
            Transform2 tranform;

            tranform.SetMatrix(pane._P,32);
            tranform.Scale(50.0, 50.0);
            tranform.Rotate(m_Angle);

            pane.Draw(memDC);

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

        SelectObject(memDC, oldBitmap);

        DeleteObject(newBitmap);
        DeleteDC(memDC);

        EndPaint(hwnd, &ps);
    }
    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;
}

HelloRevit
关注
专栏目录
图形学 ---- 二维几何变换（二维图形矩阵平移，旋转，缩放）
qq_37682160的博客
04-19 9261
二维图形几何变换，矩阵计算 前言：对于一个图形的几何变换，对应的是操作到图形中的每一个点！ 即对每一个点做出相应的几何变换。比如平移，就是对二维图形的每个点都平移相同的距离；旋转则是对每一个点，基于基准点旋转相应角度！缩放操作也是如此！ 所以下面的矩阵计算都是基于二维平面上一个点（基于基准点）的几何变换！ 二维图形平移： ’ 如上图所示：P（x,y）,P’（x’,y’），x轴平移距离：Tx，y轴平...
计算机图形学上机实验二-二维图形的基本几何变换
热门推荐
Learning_is_endless的博客
12-10 1万+
实验二  二维图形的基本几何变换 【实验目的】 1、掌握二维图形基本的几何变换原理及变换矩阵； 2、掌握矩阵运算的程序设计。 【实验性质及学时】 验证性实验，4学时 【实验内容】 以矩阵运算为数学基础，采用旋转、平移、缩放、对称等基本几何变换，对一简单的二维图形做变换。 【实验步骤】 1. 编写二维图形基本变换（包括平移、旋转、缩放、对称）的通用子程序； 2. 以（540,24...
计算机图形学实验五-二维图像几何变换
Mibbp的博客
05-15 1766
计算机图形学实验五-二维图像几何变换 视频讲解 这个内容其实非常简单，就不同变换改一下矩阵就行，但是我这里想讲的是，如何去理解他的本质，就为什么左乘一个矩阵就可以实现这种变换，矩阵到底是什么，这些问题其实应该在学线性代数的时候就该解决的，如果会的话那就没啥看的了，然后推荐大家去看3b1b的关于线代的视频，讲的非常好，搭配着动画演示很好理解，并且时间也不长，视频地址 关于几何变换的讲解都在视频里了，如果你不在意这些的话，那其实这次实验就没啥说的，我就把我写的实验报告放着就行了，因为真的没啥说的，就不同变换套不
计算机图形学12：二维图形的几何变换
你的问题在于，读书太少而想得太多。
03-24 1713
计算机图形学：二维图形的几何变换——附原理及详细代码
二维图形几何变换（计算机图形学）
baotu的博客
10-10 3679
3) 使用双缓冲机制进行图形绘制，避免运动闪烁，所有图形先绘制到用户自定的DC，绘制完成后再统一拷贝到屏幕DC。1)设计实现二维图形变换类，具有平移、比例、旋转二维几何变换功能，以及相对于任意参考点的二维复合变换功能；2)将2.2节直线类所绘制的如图2-3所示的菱形线框，绕最上端A点匀速旋转，并要求相对于A点来回缩放。只对TestView.cpp中的绘制函数进行修改，其他代码不变。2）掌握平移，比例，旋转三种基本二维几何变换矩阵生成。3）掌握相对于任意参考点的二维复合变换矩阵生成。
计算机图形学：二维图形的几何变换（算法原理及代码实现）
qq_55982881的博客
02-22 1万+
一、实现方案 　　对于一个二维图形作平移、旋转、放缩变换，可以转换为在二维坐标系中图形的所有点分别可以对应到在x，y轴方向分别平移tx，ty（平移）、绕一点旋转固定的角（旋转）、在x，y轴方向分别放缩sx，sy倍。 　　对于变换的原理，只需要将原图形的点通过极坐标或者相加、相乘，再结合二维矩阵的原理即可实现，如果图形需要对图形对象进行旋转和放缩两类变换进行多次操作，则可以首先将两变换矩阵合成一个复合变换矩阵。针对于平移是矩阵的相加，为了统一成相乘，可以用齐次坐标可以解决。 　　如下为在齐次坐标下，各原
计算机图形学实验二——二维图形几何变换及裁剪
Onlyone_1314的博客
08-23 5030
【实验名称】 二维图形几何变换及裁剪 【实验目的】 1． 通过实验，进一步理解和掌握二维几何图形的基本变换及复合变换的原理； 2． 理解和掌握cohen-sutherland裁剪算法的基本思想。 【实验原理】 1．平移变换、旋转变换、比例变换、对称变换的变换矩阵； 绕任意点旋转、相对任意点缩放的变换矩阵； 相对于任意参考点(xF,yF)的二维几何变换,基本思路是，将图形经过平移，使参考点与原点重合，此时相对于参考点的变换变成相对于原点的基本几何变换，最后再平移，使参考点回到原来的位置。 （1）
计算机图形学二维图形基本变换实验原理,江苏大学-计算机图形学第三次实验报告-二维图形变换...
weixin_36168629的博客
07-19 861
《江苏大学-计算机图形学第三次实验报告-二维图形变换》由会员分享，可在线阅读，更多相关《江苏大学-计算机图形学第三次实验报告-二维图形变换(13页珍藏版)》请在人人文库网上搜索。1、计算机科学与通信工程学院实验报告课程计算机图形学实验题目二维图形变换学生姓名学号专业班级指导教师日期成绩评定表评价内容具体内容权重得分论证分析方案论证与综合分析的正确、合理性20%算法设计算法描述的正确性与可读性20%...
二维几何变换算法
Happyunlimited的博客
07-09 3351
 l 平移变换只改变图形的位置，不改变图形的大小。l 旋转变换不改变图形的形状l 放缩变换引起图形形状的变化。 复合变换结果与变换的顺序有关（矩阵乘法不可交换）例:对一矩形先缩放S(2,0.5),再旋转R(p/6)。 对称变换关于x轴的对称变换: 关于y轴的对称变换： 例:设有一三角形ABC,其中三个顶点为A(5,10),B(1,2),C(8,5)，求对于直线-2x+3y+3=0的对称变换后的图...
计算机图形学 学习笔记 二维几何变换
漫漫无期的博客
10-02 4944
应用于对象几何描述并改变它的位置、方向或大小的操作称为几何变换。 几何变换有时也称为建模变换。建模变换一般用于构造场景或给出由多个部分组合而成的复杂对象的层次式描述等。
案例11－二维图形几何变换算法.rar_二维几何变换_二维图形几何变换_二维图形变换_几何变换_几何图形
09-23
"案例11－二维图形几何变换算法.rar"很可能包含了关于如何在C++中实现这些变换的代码实例和详细解释。 二维几何变换主要包括以下几种类型： 1. **平移（Translation）**：这是最基础的变换，通过将图形沿着x轴、y...
计算机图形学（MFC）- 二维基本几何变换算法
02-07
在这个主题中，我们重点关注MFC（Microsoft Foundation Classes）框架下，使用C++实现的二维基本几何变换算法。MFC是微软为Windows应用程序开发提供的一个类库，它简化了Windows API的使用，使得开发者能够更方便地...
二维基本图形几何变换算法（用VC++实现）
06-10
总结，二维基本图形的几何变换算法是计算机图形学的基础，通过VC++可以实现这些变换，创建一个交互式应用，使用户能够直观地理解和探索各种变换的效果。这个项目不仅可以提高编程技巧，还能加深对几何变换理论的理解...
计算机图形学MFC-双缓冲二维图形几何变换算法-c/c++代码 .rar
03-08
（系统会自己调高积分，我重新改成5分啦！...大学计算机图形学课程作业代码，使用双缓冲技术，实现平移、比例、旋转、反射错切变换。自用，代码完整。打包下载，可直接运行。c/c++语言MFC实现。支持vs。
计算机图形学-三维图形几何变换.rar
10-28
三维图形几何变换算法的自我演示exe文件则提供了实践经验，让你能够亲眼看到这些变换如何影响物体。通过交互式地调整变换参数，你可以更深入地理解每种变换的效果，这对于学习和掌握这些概念至关重要。 总的来说，...
二叉树系列 10/11
最新发布
2301_78191305的博客
10-11 261
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
Java 插入排序
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
10-08 250
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
打卡第四天 P1081 [NOIP2012 提高组] 开车旅行
hjxxlsx的博客
10-06 445
【代码】打卡第四天 P1081 [NOIP2012 提高组] 开车旅行。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 1297
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值