CG3-v2.0-图形几何变换-计算机图形学-头歌

已于 2024-08-01 16:12:45 修改
阅读量446 收藏 17
点赞数 25
分类专栏： 头歌计算机视觉代码 文章标签： 计算机视觉 c++ opencv
于 2024-08-01 16:12:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52766015/article/details/140850458
版权

第1关：平移、缩放、旋转正方体

一. 任务描述
1. 本关任务
(1) 理解几何变换基本原理, 掌握平移、旋转、缩放变换的方法;
(2) 根据平移算法原理补全translation、scale、rotation_x、rotation_y和rotation_z函数;
(3) 根据几何变换基本原理,将main函数中的translation、scale、rotation_z参数补充完整。

2. 输入
(1) 代码将自动输入一个边长为1的obj正方体模型，具体模型如下图：

(2) 代码自动将模型投影到二维平面上生成一个边长为1的白色正方形，并且代码会生成红色x轴，绿色y轴，具体图片如下所示：

(3) 将立方体的顶点坐标分别向x,y,z轴正方向平移0.5个单位距离，然后绘制一个红色正方形；
(4) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍，然后绘制一个绿色正方形；
(5) 将立方体的顶点坐标沿z轴逆时针方向旋转45度，然后绘制一个黄色正方形。

3. 输出
具体结果如下图所示：
 

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
using namespace std;
const double PI = acos(-1.0);
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
    bool steep = false;
    if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
    {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x > p1.x)
    {
        std::swap(p0.x, p1.x);
        std::swap(p0.y, p1.y);
    }
    int dx = p1.x - p0.x;
    int dy = std::abs(p1.y - p0.y);
    int y = p0.y;
    int d = -dx;
    for (int x = p0.x; x <= p1.x; x++)
    {
        if (steep)
            image.set(y, x, color);
        else
            image.set(x, y, color);
        d = d + 2 * dy;
        if (d > 0)
        {
            y += (p1.y > p0.y ? 1 : -1);
            d = d - 2 * dx;
        }
    }
}
Matrix viewport(int x, int y, int w, int h, int depth) {
    Matrix m = Matrix::identity(4);
    m[0][3] = x + w / 2.f;
    m[1][3] = y + h / 2.f;
    m[2][3] = depth / 2.f;
    m[0][0] = w / 2.f;
    m[1][1] = h / 2.f;
    m[2][2] = depth / 2.f;
    return m;
}
Matrix translation(Vec3f v) {
    Matrix Tr = Matrix::identity(4);
    // Please add the code here
    /********** Begin ********/
    Tr[0][3] = v.x;
    Tr[1][3] = v.y;
    Tr[2][3] = v.z;
    /********** End *********/
    return Tr;
}
Matrix scale(float factorX, float factorY, float factorZ)
{
    Matrix Z = Matrix::identity(4);
    /********** Begin ********/
    Z[0][0] = factorX;
    Z[1][1] = factorY;
    Z[2][2] = factorZ;
    /********** End *********/
    return Z;
}
Matrix rotation_x(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    /********** Begin ********/
    R[1][1] = R[2][2] = cosangle;
    R[1][2] = -sinangle;
    R[2][1] = sinangle;
    /********** End *********/
    return R;
}
Matrix rotation_y(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    /********** Begin ********/
    R[0][0] = R[2][2] = cosangle;
    R[0][2] = sinangle;
    R[2][0] = -sinangle;
    /********** End *********/
    return R;
}
Matrix rotation_z(float angle) {
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    /********** Begin ********/
    R[0][0] = R[1][1] = cosangle;
    R[0][1] = -sinangle;
    R[1][0] = sinangle;
    /********** End *********/
    return R;
}
int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("../step3/cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    { // draw the axes
        Vec3f x(1.f, 0.f, 0.f), y(0.f, 1.f, 0.f), o(0.f, 0.f, 0.f);
        o = VP*o;
        x = VP*x;
        y = VP*y;
        line(o, x, image, red);
        line(o, y, image, green);
    }
    for (int i = 0; i < model->nfaces(); i++) {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++) {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            // draw the original model
            Vec3f op0 = VP*wp0;
            Vec3f op1 = VP*wp1;
            line(op0, op1, image, white);
            // draw the translated model
            // Please add the code here
            /********** Begin ********/
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            /********** End *********/
            Vec3f tp0 = VP*T*wp0;
            Vec3f tp1 = VP*T*wp1;
            line(tp0, tp1, image, red);
            // draw the scaled model
            // Please add the code here
            /********** Begin ********/            
            Matrix S = scale(0.5, 0.5, 0.5);
            /********** End *********/
            Vec3f sp0 = VP*S*wp0;
            Vec3f sp1 = VP*S*wp1;
            line(sp0, sp1, image, green);
            // draw the rotated model
            // Please add the code here
            /********** Begin ********/   
            Matrix R = rotation_z(45);
            /********** End *********/
            Vec3f rp0 = VP*R*wp0;
            Vec3f rp1 = VP*R*wp1;
            line(rp0, rp1, image, yellow);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step3/test.png");
    delete model;
    return 0;
}


第2关：图形的平移与缩放

一. 任务描述
1. 本关任务
(1) 理解几何变换基本原理, 掌握平移和缩放变换的方法;
(2) 根据几何变换基本原理,将main函数中的空白部分补充完整。

2. 输入
(1) 代码将自动输入一个边长为1的obj正方体模型，具体模型如下图：

(2) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍，然后绘制一个白色正方形；
(3) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍，再分别向x,y,z轴正方向平移0.5个单位距离，然后绘制一个红色正方形；
(4) 将立方体的顶点坐标分别向x,y,z轴正方向平移0.5个单位距离，再分别沿x,y,z轴方向缩放0.5倍，然后绘制一个绿色正方形。

3. 输出
具体结果如下图所示：

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
using namespace std;
const double PI = acos(-1.0);
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
    bool steep = false;
    if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
    {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x > p1.x)
    {
        std::swap(p0.x, p1.x);
        std::swap(p0.y, p1.y);
    }
    int dx = p1.x - p0.x;
    int dy = std::abs(p1.y - p0.y);
    int y = p0.y;
    int d = -dx;
    for (int x = p0.x; x <= p1.x; x++)
    {
        if (steep)
            image.set(y, x, color);
        else
            image.set(x, y, color);
        d = d + 2 * dy;
        if (d > 0)
        {
            y += (p1.y > p0.y ? 1 : -1);
            d = d - 2 * dx;
        }
    }
}
Vec3f m2v(Matrix m) {
    return Vec3f(m[0][0] / m[3][0], m[1][0] / m[3][0], m[2][0] / m[3][0]);
}
Matrix v2m(Vec3f v) {
    Matrix m(4, 1);
    m[0][0] = v.x;
    m[1][0] = v.y;
    m[2][0] = v.z;
    m[3][0] = 1.f;
    return m;
}
Matrix viewport(int x, int y, int w, int h, int depth) {//视角变换
    Matrix m = Matrix::identity(4);
    m[0][3] = x + w / 2.f;
    m[1][3] = y + h / 2.f;
    m[2][3] = depth / 2.f;
    m[0][0] = w / 2.f;
    m[1][1] = h / 2.f;
    m[2][2] = depth / 2.f;
    return m;
}
Matrix translation(Vec3f v) {//平移变换
    Matrix Tr = Matrix::identity(4);
    Tr[0][3] = v.x;
    Tr[1][3] = v.y;
    Tr[2][3] = v.z;
    return Tr;
}
Matrix scale(float factorX, float factorY, float factorZ)//缩放变换
{
    Matrix Z = Matrix::identity(4);
    Z[0][0] = factorX;
    Z[1][1] = factorY;
    Z[2][2] = factorZ;
    return Z;
}
Matrix rotation_x(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[1][1] = R[2][2] = cosangle;
    R[1][2] = -sinangle;
    R[2][1] = sinangle;
    return R;
}
Matrix rotation_y(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[2][2] = cosangle;
    R[0][2] = sinangle;
    R[2][0] = -sinangle;
    return R;
}
Matrix rotation_z(float angle) {
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[1][1] = cosangle;
    R[0][1] = -sinangle;
    R[1][0] = sinangle;
    return R;
}
int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");//这个是创建一个三维矩形
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);//这个就是视点变换 
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            // draw the model after scaled
            Vec3f op0 = VP * swp0;
            Vec3f op1 = VP * swp1;
            line(op0, op1, image, white);
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            Matrix S = scale(0.5, 0.5, 0.5);
            // scaled then translated
            Vec3f tsp0 = VP*T*S*swp0;
            Vec3f tsp1 = VP*T*S*swp1;
            line(tsp0, tsp1, image, red);
            // translated then scaled
            Vec3f stp0 = VP*S*T*swp0;
            Vec3f stp1 = VP*S*T*swp1;
            line(stp0, stp1, image, green);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step2/test.png");
    delete model;
    return 0;
}

第3关：图形的平移与旋转

一. 任务描述
1. 本关任务
(1) 理解几何变换基本原理, 掌握平移和旋转变换的方法;
(2) 根据几何变换基本原理,将main函数中的空白部分补充完整。

2. 输入
(1) 代码将自动输入一个边长为1的obj正方体模型，具体模型如下图：

(2) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍，然后绘制一个白色正方形；
(3) 将立方体的顶点坐标分别向x,y,z轴正方向平移0.5个单位距离，再沿z轴逆时针方向旋转45度，然后绘制一个绿色正方形
(4) 将立方体的顶点坐标分别沿z轴逆时针方向旋转45度，再分别向x,y,z轴正方向平移0.5个单位距离，然后绘制一个红色正方形；

3. 输出
具体结果如下图所示：

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
using namespace std;
const double PI = acos(-1.0);
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
    bool steep = false;
    if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
    {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x > p1.x)
    {
        std::swap(p0.x, p1.x);
        std::swap(p0.y, p1.y);
    }
    int dx = p1.x - p0.x;
    int dy = std::abs(p1.y - p0.y);
    int y = p0.y;
    int d = -dx;
    for (int x = p0.x; x <= p1.x; x++)
    {
        if (steep)
            image.set(y, x, color);
        else
            image.set(x, y, color);
        d = d + 2 * dy;
        if (d > 0)
        {
            y += (p1.y > p0.y ? 1 : -1);
            d = d - 2 * dx;
        }
    }
}
Vec3f m2v(Matrix m) {
    return Vec3f(m[0][0] / m[3][0], m[1][0] / m[3][0], m[2][0] / m[3][0]);
}
Matrix v2m(Vec3f v) {
    Matrix m(4, 1);
    m[0][0] = v.x;
    m[1][0] = v.y;
    m[2][0] = v.z;
    m[3][0] = 1.f;
    return m;
}
Matrix viewport(int x, int y, int w, int h, int depth) {
    Matrix m = Matrix::identity(4);
    m[0][3] = x + w / 2.f;
    m[1][3] = y + h / 2.f;
    m[2][3] = depth / 2.f;
    m[0][0] = w / 2.f;
    m[1][1] = h / 2.f;
    m[2][2] = depth / 2.f;
    return m;
}
Matrix translation(Vec3f v) {
    Matrix Tr = Matrix::identity(4);
    Tr[0][3] = v.x;
    Tr[1][3] = v.y;
    Tr[2][3] = v.z;
    return Tr;
}
Matrix scale(float factorX, float factorY, float factorZ)
{
    Matrix Z = Matrix::identity(4);
    Z[0][0] = factorX;
    Z[1][1] = factorY;
    Z[2][2] = factorZ;
    return Z;
}
Matrix rotation_x(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[1][1] = R[2][2] = cosangle;
    R[1][2] = -sinangle;
    R[2][1] = sinangle;
    return R;
}
Matrix rotation_y(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[2][2] = cosangle;
    R[0][2] = sinangle;
    R[2][0] = -sinangle;
    return R;
}
Matrix rotation_z(float angle) {
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[1][1] = cosangle;
    R[0][1] = -sinangle;
    R[1][0] = sinangle;
    return R;
}
int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            // draw the model after scaled
            Vec3f op0 = VP * swp0;
            Vec3f op1 = VP * swp1;
            line(op0, op1, image, white);
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            Matrix S = scale(0.5, 0.5, 0.5);
            Matrix R = rotation_z(45);
            // translated then rotated
            Vec3f rtp0 = VP*R*T*swp0;
            Vec3f rtp1 = VP*R*T*swp1;
            line(rtp0, rtp1, image, green);
            // rotated then translated
            Vec3f trp0 = VP*T*R*swp0;
            Vec3f trp1 = VP*T*R*swp1;
            line(trp0, trp1, image, red);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step1/test.png");
    delete model;
    return 0;
}

第4关：图形的旋转与缩放

一. 任务描述
1. 本关任务
(1) 理解几何变换基本原理, 掌握旋转和缩放变换的方法;
(2) 根据几何变换基本原理,将main函数中的空白部分补充完整。

2. 输入
(1) 代码将自动输入一个边长为1的obj正方体模型，具体模型如下图：

(2) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍，然后绘制一个白色正方形；
(3) 将立方体的顶点坐标分别向y,z轴缩放0.5倍，x轴保持不变，再沿z轴逆时针方向旋转45度，然后绘制一个绿色矩形；
(4) 将立方体的顶点坐标分别沿z轴逆时针方向旋转45度，再分别向y,z轴缩放0.5倍，x轴保持不变，然后绘制一个红菱形。

3. 输出
具体结果如下图所示：

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
using namespace std;
const double PI = acos(-1.0);
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
    bool steep = false;
    if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
    {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x > p1.x)
    {
        std::swap(p0.x, p1.x);
        std::swap(p0.y, p1.y);
    }
    int dx = p1.x - p0.x;
    int dy = std::abs(p1.y - p0.y);
    int y = p0.y;
    int d = -dx;
    for (int x = p0.x; x <= p1.x; x++)
    {
        if (steep)
            image.set(y, x, color);
        else
            image.set(x, y, color);
        d = d + 2 * dy;
        if (d > 0)
        {
            y += (p1.y > p0.y ? 1 : -1);
            d = d - 2 * dx;
        }
    }
}
Vec3f m2v(Matrix m) {
    return Vec3f(m[0][0] / m[3][0], m[1][0] / m[3][0], m[2][0] / m[3][0]);
}
Matrix v2m(Vec3f v) {
    Matrix m(4, 1);
    m[0][0] = v.x;
    m[1][0] = v.y;
    m[2][0] = v.z;
    m[3][0] = 1.f;
    return m;
}
Matrix viewport(int x, int y, int w, int h, int depth) {
    Matrix m = Matrix::identity(4);
    m[0][3] = x + w / 2.f;
    m[1][3] = y + h / 2.f;
    m[2][3] = depth / 2.f;
    m[0][0] = w / 2.f;
    m[1][1] = h / 2.f;
    m[2][2] = depth / 2.f;
    return m;
}
Matrix translation(Vec3f v) {
    Matrix Tr = Matrix::identity(4);
    Tr[0][3] = v.x;
    Tr[1][3] = v.y;
    Tr[2][3] = v.z;
    return Tr;
}
Matrix scale(float factorX, float factorY, float factorZ)
{
    Matrix Z = Matrix::identity(4);
    Z[0][0] = factorX;
    Z[1][1] = factorY;
    Z[2][2] = factorZ;
    return Z;
}
Matrix rotation_x(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[1][1] = R[2][2] = cosangle;
    R[1][2] = -sinangle;
    R[2][1] = sinangle;
    return R;
}
Matrix rotation_y(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[2][2] = cosangle;
    R[0][2] = sinangle;
    R[2][0] = -sinangle;
    return R;
}
Matrix rotation_z(float angle) {
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[1][1] = cosangle;
    R[0][1] = -sinangle;
    R[1][0] = sinangle;
    return R;
}
int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 500;
    const int height = 500;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            // draw the model after scaled
            Vec3f op0 = VP * swp0;
            Vec3f op1 = VP * swp1;
            line(op0, op1, image, white);
            Matrix T = translation(Vec3f(0.5, 0.5, 0.5));
            Matrix S = scale(1, 0.5, 0.5);
            Matrix R = rotation_z(45);
            // scaled then rotated
            Vec3f rsp0 = VP*R*S*swp0;
            Vec3f rsp1 = VP*R*S*swp1;
            line(rsp0, rsp1, image, green);
            // rotated then scaled
            Vec3f srp0 = VP*S*R*swp0;
            Vec3f srp1 = VP*S*R*swp1;
            line(srp0, srp1, image, red);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step4/test.png");
    delete model;
    return 0;
}

第5关：绘制三菱形状

一. 任务描述
1. 本关任务
(1) 理解几何变换基本原理, 掌握平移、旋转和缩放变换的方法;
(2) 根据几何变换基本原理,将main函数中的空白部分补充完整来绘制三菱形状。

2. 输入
(1) 代码将自动输入一个边长为1的obj正方体模型，具体模型如下图：

(2) 将立方体的顶点坐标分别沿x,y,z轴方向缩放0.5倍；
(3) 将立方体的顶点坐标分别沿z轴逆时针方向旋转45度，再分别向y,z轴缩放0.5倍，x轴保持不变，然后绘制一个红菱形；
(4) 将红色菱形沿着x轴正方向平移 个单位距离，然后将红菱形沿Z轴逆时针旋转90度；
(5)绿色和黄色菱形与红色菱形的夹角均为120度。

#include <vector>
#include <cmath>
#include <algorithm>
#include <iostream>
#include "model.h"
#include "geometry.h"
#include "pngimage.h"
using namespace std;
const double PI = acos(-1.0);
void line(Vec3i p0, Vec3i p1, PNGImage  &image, PNGColor color)
{
    bool steep = false;
    if (std::abs(p0.x - p1.x) < std::abs(p0.y - p1.y))
    {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x > p1.x)
    {
        std::swap(p0.x, p1.x);
        std::swap(p0.y, p1.y);
    }
    int dx = p1.x - p0.x;
    int dy = std::abs(p1.y - p0.y);
    int y = p0.y;
    int d = -dx;
    for (int x = p0.x; x <= p1.x; x++)
    {
        if (steep)
            image.set(y, x, color);
        else
            image.set(x, y, color);
        d = d + 2 * dy;
        if (d > 0)
        {
            y += (p1.y > p0.y ? 1 : -1);
            d = d - 2 * dx;
        }
    }
}
Vec3f m2v(Matrix m) {
    return Vec3f(m[0][0] / m[3][0], m[1][0] / m[3][0], m[2][0] / m[3][0]);
}
Matrix v2m(Vec3f v) {
    Matrix m(4, 1);
    m[0][0] = v.x;
    m[1][0] = v.y;
    m[2][0] = v.z;
    m[3][0] = 1.f;
    return m;
}
Matrix viewport(int x, int y, int w, int h, int depth) {
    Matrix m = Matrix::identity(4);
    m[0][3] = x + w / 2.f;
    m[1][3] = y + h / 2.f;
    m[2][3] = depth / 2.f;
    m[0][0] = w / 2.f;
    m[1][1] = h / 2.f;
    m[2][2] = depth / 2.f;
    return m;
}
Matrix translation(Vec3f v) {
    Matrix Tr = Matrix::identity(4);
    Tr[0][3] = v.x;
    Tr[1][3] = v.y;
    Tr[2][3] = v.z;
    return Tr;
}
Matrix scale(float factorX, float factorY, float factorZ)
{
    Matrix Z = Matrix::identity(4);
    Z[0][0] = factorX;
    Z[1][1] = factorY;
    Z[2][2] = factorZ;
    return Z;
}
Matrix rotation_x(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[1][1] = R[2][2] = cosangle;
    R[1][2] = -sinangle;
    R[2][1] = sinangle;
    return R;
}
Matrix rotation_y(float angle)
{
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[2][2] = cosangle;
    R[0][2] = sinangle;
    R[2][0] = -sinangle;
    return R;
}
Matrix rotation_z(float angle) {
    angle = angle * PI / 180;
    float sinangle = sin(angle);
    float cosangle = cos(angle);
    Matrix R = Matrix::identity(4);
    R[0][0] = R[1][1] = cosangle;
    R[0][1] = -sinangle;
    R[1][0] = sinangle;
    return R;
}
int main(int argc, char** argv)
{
    const PNGColor white = PNGColor(255, 255, 255, 255);
    const PNGColor black = PNGColor(0, 0, 0, 255);
    const PNGColor red = PNGColor(255, 0, 0, 255);
    const PNGColor green = PNGColor(0, 255, 0, 255);
    const PNGColor blue = PNGColor(0, 0, 255, 255);
    const PNGColor yellow = PNGColor(255, 255, 0, 255);
    Model *model = NULL;
    const int width = 800;
    const int height = 800;
    const int depth = 255;
    //generate some image
    PNGImage image(width, height, PNGImage::RGBA); //Error when RGB because lodepng_get_raw_size_lct(w, h, colortype, bitdepth) > in.size() in encode
    image.init(black);
    model = new Model("cube.obj");
    Matrix VP = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        std::vector<int> face = model->face(i);
        for (int j = 0; j < (int)face.size(); j++)
        {
            Vec3f wp0 = model->vert(face[j]);
            Vec3f wp1 = model->vert(face[(j + 1) % face.size()]);
            Matrix S0 = scale(0.5, 0.5, 0.5);
            Vec3f swp0 = S0 * wp0;
            Vec3f swp1 = S0 * wp1;
            Matrix S = scale(1, 0.5, 0.5);
            Matrix R1 = rotation_z(45);
            Matrix T = translation(Vec3f(sqrt(2)/2, 0, 0));
            Matrix R2 = rotation_z(90);
            // 中间坚直的菱形
            Vec3f mp0 = VP*R2*T*S*R1*swp0;
            Vec3f mp1 = VP*R2*T*S*R1*swp1;
            line(mp0, mp1, image, red);
            // 左边的菱形
            Matrix R3 = rotation_z(120);
            Vec3f lp0 = VP * R3* R2*T*S*R1*swp0;
            Vec3f lp1 = VP * R3* R2*T*S*R1*swp1;
            line(lp0, lp1, image, green);
            // 右边的菱形
            Matrix R4 = rotation_z(-120);
            Vec3f rp0 = VP * R4* R2*T*S*R1*swp0;
            Vec3f rp1 = VP * R4* R2*T*S*R1*swp1;
            line(rp0, rp1, image, yellow);
        }
    }
    image.flip_vertically(); // i want to have the origin at the left bottom corner of the image
    image.write_png_file("../img_step5/test.png");
    delete model;
    return 0;
}

正在变秃的程序猿
关注
  • 25
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
CG3-v2.0-图形几何变换
Junds0的博客
09-23 1732
(1) 理解几何变换基本原理, 掌握平移、旋转、缩放变换的方法; (2) 根据平移算法原理补全translation、scale、rotation_x、rotation_y和rotation_z函数; (3) 根据几何变换基本原理,将main函数中的translation、scale、rotation_z参数补充完整。 第2关：图形的平移与缩放 (1) 理解几何变换基本原理, 掌握平移和缩放变换的方法; (2) 根据几何变换基本原理,将main函数中的空白部分补充完整。 第3关：图形的平移与旋转 (1) 理
计算机图形学图象几何变换
06-16
几何变换是最常见的图像处理手段，通过对变形的图像进行几何校正，可以得出准确的图像。常用的几何变换功能包括图像的平移、图像的镜像变换、图像的转置、图像的缩放、图像的旋转等等。
三维图形几何变换算法实验_计算机图形学 CG
weixin_39693437的博客
12-17 910
计算机图形学是研究怎样利用计算机来显示，生成和处理图形的原理，方法和技术的一门学科。IEEE定义：Computer graphics is the art or science of producing graphical images with the aid computer。通常意义下的图形：能够在人的视觉系统中形成视觉印象的客观对象图形的表示点阵法是用具有颜色信息的点阵来表示图形...
计算机图形与OpenGL学习五(二维几何变换1.平移、旋转、缩放)
热门推荐
lhs322的博客
04-12 1万+
二维几何变换（平移、旋转、缩放）本章涉及数学变换比较多，代码是次要的，数学理论可自己推导一下。【二维平移】通过将二维量加到一个点的坐标上来生成一个新的坐标位置，可以实现一次平移。将平移距离加到原始坐标上获得一个新的坐标,实现一个二维位置的平移。为平移向量，使用列向量来表示各点坐标的话：实例：对一个四边形进行平移，平移量自己输入，结果图平移量为(200，200)，代码：#include&lt;GL/...
计算机图形学-二维变换
weixin_44049693的博客
12-02 1177
实验一 // 提示：写完代码请保存之后再进行评测 #include <GL/freeglut.h> #include<stdio.h> // 评测代码所用头文件-开始 #include<opencv2/core/core.hpp> #include<opencv2/highgui/highgui.hpp> #include<opencv2/imgproc/imgproc.hpp> // 评测代码所用头文件-结束 void init(void) {
计组头歌实验答案，可直接上传头歌提交
03-15
"计组头歌实验答案"这个标题表明这是一份与计算机组成原理实验相关的资料，可能包含了对一系列实验问题的解答，而"可直接上传头歌提交"则暗示这可能是某在线学习平台或教学系统的作业提交格式。 1、运算器设计(HUST...
《Unity Shader 与 计算机图形学》第二章
Winshare
02-04 4940
提示：本篇将会非常长~ 本系列文章分为硬件编程入门工程实践上一篇主要介绍了GPU的特征工作原理 以及渲染的底层流程 其实对于新架构而言还有所不同
论文研究-命令集驱动的快速造型系统.pdf
07-22
这种技术在CAD（计算机辅助设计）和CG（计算机图形学）中广泛应用，以创建三维模型和场景。 4. 面向对象设计 - 快速造型系统的构建还涉及了面向对象设计的概念，这是一种软件工程范式，其核心思想是将数据和对数据...
图形学复习
qq_41956860的博客
12-30 1378
文章目录charpter1图形学的基本应用(C1，E33)光栅图形，相关定义（如像素、真彩色、帧缓存等）与计算(C4,E35)图形学的历史(CG01)人类视觉系统(C16)（如光谱(C13)、颜色模型(C49, E98)）三维图形的处理流程（如顶点、裁剪、光栅化、片元等）(C25，E65)chapter2OpenGL 与 WebGL简介OpenGL 与WebGL函数的使用颜色索引(C51)chap...
二维/三维图形的几何变换（基于OpenGL）
11-29
支持二维和三维图形的几何变换代码，变换包括平移、旋转、对称、投影、错切等
CG-二维三维图形变换-学习笔记
weixin_30511039的博客
10-20 262
一、计算机图形学中坐标系分类 世界坐标系、建模坐标系、观察坐标系、设备坐标系、规范化坐标系 其中：规范化坐标系是一个中间坐标系，坐标值取值范围0-1； 二、二维图形变换 1. 变换种类：比例、旋转、镜像、错切、平移等； 2. 仿射变换：是一种二维坐标到二维坐标的线性变换。满足：平直性（直线经过变换之后依然是直线）、平行性（平行线依然是平行线）； 3. 齐次坐标表示法：用一个n+1维的向...
实验3 OpenGL几何变换
weixin_34032779的博客
10-30 843
1．实验目的： 理解掌握一个OpenGL程序平移、旋转、缩放变换的方法。 2．实验内容： （1）阅读实验原理，运行示范实验代码，掌握OpenGL程序平移、旋转、缩放变换的方法； （2）根据示范代码，尝试完成实验作业； 3．实验原理： （1）OpenGL下的几何变换 在OpenGL的核心库中，每一种几何变换都有一个独立的函数，所有变换都在三维空间中定义。 平移矩阵构造函数为glTra...
计算机图形学头歌实训平台图形几何变换答案
最新发布
m0_74822776的博客
11-13 1140
添加QQ号2803013946获取提取码。第3~5关代码请查看。
【计算机图形学】实验二 几何变换（实验报告分析+截图+源码）
m0_55931547的博客
06-07 767
实现OpenGL程序平移、旋转、缩放变化功能
3.变换（Transform）
Mr_Dongzheng的博客
10-30 343
这三个旋转的角度也被叫做欧拉角，欧拉角通常使用三个角度来描述旋转，这三个角度分别表示绕三个坐标轴（通常是x、y和z轴）的旋转量。更多的用来计算旋转间的插值。比如根据旋转15度和旋转25度的公式相加之后求平均并不是旋转20度的公式，但是四元数可以方便的根据这两个旋转角度插值计算出旋转20度的公式。这里绕Y'轴旋转的矩阵有些不一样是因为Y轴是Z叉乘X，但计算的时候是先算X坐标再算Z坐标，与叉乘顺序相反，所以Y旋转是逆的。绕固定坐标轴的旋转（XYZ顺序）：首先绕X轴旋转，然后绕Y轴，最后绕Z轴。
【J2me3D系列学习文章之三】（立即模式）对立方体进行变换操作-旋转、缩放、平移
李华明Himi
12-09 8195
李华明Himi 原创,转载务必在明显处注明：转载自【黑米GameDev街区】 原文链接: http://www.himigame.com/j2me-kjava/262.html   上一篇文章讲述了如何构造一个简单的立方体，以及对立方体设定颜色，那么这一章学习对立方体进行变换操作。   对上一篇文章的学习中也强调了两个 Transform 对象的不同之处，这里不多说了。操作立方体其实就是渲染的时候
头歌计算机图形学实验（图形几何变换和模型观察和视口变换）
hanlepeng的博客
10-23 1029
x 0)1 : -1);return m;return Tr;return Z;return R;return R;
css2D、3D详解
weixin_69474694的博客
07-15 566
css2D、3D详解
头歌cg3-v2.0-图形几何变换
10-25
头歌cg3-v2.0-图形几何变换是一种计算机图形处理技术，可以对图形进行各种几何变换，如平移、旋转、缩放和投影等。该技术广泛应用在图形设计、游戏开发和虚拟现实等领域。 平移是指将图形沿着某个方向进行移动，不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

正在变秃的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值