基本2D几何变换_2021秋季《计算机图形学》_基于《计算机图形学（第四版）》D.H.&M.P.B.&W.R.C.

• 目前进度：多边形的平移、旋转、缩放

一、实验目的

• 实现线段、圆和多边形的基本2D几何变换
  • 平移
  • 旋转（含基准点）
  • 缩放（含基准点）

二、实验环境

• Visual Studio 2019
• Windows 10

三、算法分析与设计

多边形

平移

对于多边形的各顶点添加一段平移距离，
$$\{\begin{array}{l}{x}^{\prime }=x+tx\\ y^{\prime }=y+ty\end{array}$$
记原多边形顶点为$P$，平移后的多边形顶点为$P^{\prime }$，平移向量为$T$，则
$$P=\left[\begin{array}{c}x\\ y\end{array}\right],P^{\prime }=\left[\begin{array}{c}{x}^{\prime }\\ y^{\prime }\end{array}\right],T=\left[\begin{array}{c}tx\\ ty\end{array}\right]$$

$$P^{\prime }=P+T$$

旋转

对于多边形的各顶点，绕基准点$(x_r,y_r)$逆时针旋转角度$\theta$，
$$\{\begin{array}{l}{x}^{\prime }-x_r=(x-x_r)\mathrm{c}\mathrm{o}\mathrm{s}\theta -(y-y_r)\mathrm{s}\mathrm{i}\mathrm{n}\theta \\ y^{\prime }-y_r=(x-x_r)\mathrm{s}\mathrm{i}\mathrm{n}\theta +(y-y_r)\mathrm{c}\mathrm{o}\mathrm{s}\theta \end{array}$$

$$P^{\prime }=R\cdot P,R=\left[\begin{array}{cc}\mathrm{c}\mathrm{o}\mathrm{s}\theta & -\mathrm{s}\mathrm{i}\mathrm{n}\theta \\ \mathrm{s}\mathrm{i}\mathrm{n}\theta & \mathrm{c}\mathrm{o}\mathrm{s}\theta \end{array}\right]$$

缩放

对于多边形的各顶点，保持基准点不动进行缩放，其中$s_x,s_y$为$x,y$方向的缩放比例。
$$\{\begin{array}{l}{x}^{\prime }=x\cdot s_x\\ y^{\prime }=y\cdot s_y\end{array}$$

$$P^{\prime }=S\cdot P,S=\left[\begin{array}{cc}{s}_x& 0\\ 0& s_y\end{array}\right]$$

四、实验结果

五、附录

#include<GL/glew.h>
#include <GLFW/glfw3.h>
#include<bits/stdc++.h>

#define PI acos(-1)

using namespace std;

struct wcPt2D
{
    GLfloat x, y;

};

wcPt2D verts[3];
wcPt2D pivPt;

void getVerts(wcPt2D* verts)
{
    verts[0].x = -0.7;
    verts[0].y = 0.5;
    verts[1].x = -0.5;
    verts[1].y = 0.7;
    verts[2].x = -0.6;
    verts[2].y = 0.7;
}

/*画出原来的多边形*/
void drawOriginalPolygon(wcPt2D* verts, GLint nVerts)
{
    glBegin(GL_POLYGON);
    for (int k = 0; k < nVerts; k++)
    {
        glVertex2f(verts[k].x, verts[k].y);
    }
    glEnd();
}

/*平移多边形*/
void translatePolygon(wcPt2D* verts, GLint nVerts, GLfloat tx, GLfloat ty)
// (tx,ty)为平移向量
{
    wcPt2D* tmp = new wcPt2D[nVerts];
    for (int k = 0; k < nVerts; k++)
    {
        tmp[k].x = verts[k].x + tx;
        tmp[k].y = verts[k].y + ty;
    }
    glBegin(GL_POLYGON);
    for (int k = 0; k < nVerts; k++)
    {
        glVertex2f(tmp[k].x, tmp[k].y);
    }
    glEnd();
}

/*旋转多边形*/
void rotatePolygon(wcPt2D* verts, GLint nVerts, wcPt2D pivPt, GLdouble theta)
// pivPt:基准点；theta：逆时针旋转角度
{
    float xr = pivPt.x;
    float yr = pivPt.y;
    wcPt2D* tmp = new wcPt2D[nVerts];
    for (int k = 0; k < nVerts; k++)
    {
        tmp[k].x = xr + (verts[k].x - xr) * cos(theta) - (verts[k].y - yr) * sin(theta);
        tmp[k].y = yr + (verts[k].x - xr) * sin(theta) + (verts[k].y - yr) * cos(theta);
    }
    glBegin(GL_POLYGON);
    for (int k = 0; k < nVerts; k++)
    {
        glVertex2f(tmp[k].x, tmp[k].y);
    }
    glEnd();
}

/*缩放多边形*/
void scalePolygon(wcPt2D* verts, GLint nVerts, wcPt2D pivPt, GLfloat sx, GLfloat sy)
// pivPt：基准点
{
    float xr = pivPt.x;
    float yr = pivPt.y;
    wcPt2D* tmp = new wcPt2D[nVerts];
    for (int k = 0; k < nVerts; k++)
    {
        tmp[k].x = sx * verts[k].x + (1 - sx) * xr;
        tmp[k].y = sy * verts[k].y + (1 - sy) * yr;
    }
    glBegin(GL_POLYGON);
    for (int k = 0; k < nVerts; k++)
    {
        glVertex2f(tmp[k].x, tmp[k].y);
    }
    glEnd();
}

int main(void)
{
    GLFWwindow* window;

    /* Initialize the library */
    if (!glfwInit())
        return -1;

    /* Create a windowed mode window and its OpenGL context */
    window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        return -1;
    }

    /* Make the window's context current */
    glfwMakeContextCurrent(window);

    if (glewInit() != GLEW_OK)
        cout << "Error!" << endl;

    // cout << glGetString(GL_VERSION) << endl;

    getVerts(verts);
    cout << verts[1].x << endl;

    /* Loop until the user closes the window */
    while (!glfwWindowShouldClose(window))
    {
        /* Render here */
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        drawOriginalPolygon(verts,3);
        translatePolygon(verts, 3, 0.5f, 0.0f);
        pivPt.x = 0.0f;
        pivPt.y = 0.0f;
        //pivPt = verts[0];
        rotatePolygon(verts, 3, pivPt, PI / 3);
        scalePolygon(verts, 3, pivPt, 0.5f, 0.5f);

        /* Swap front and back buffers */
        glfwSwapBuffers(window);

        /* Poll for and process events */
        glfwPollEvents();
    }

    glfwTerminate();
    return 0;
}