Games101观测变换（视图变换、投影变换）、光栅化

最新推荐文章于 2022-09-30 08:54:59 发布
最新推荐文章于 2022-09-30 08:54:59 发布
阅读量1k 收藏 1
点赞数
分类专栏： games101 文章标签： 几何学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzh123353/article/details/121753569
版权

Games101

文章目录

变换

齐次坐标

在这里插入图片描述

缩放变换与平移变换

在这里插入图片描述

旋转操作

在这里插入图片描述

3D旋转：
在这里插入图片描述
在这里插入图片描述

观测变换

在这里插入图片描述
定义相机的位置、视角：
在这里插入图片描述
规定相机放置在(0,0,0)位置，看往-z方向，向上是y轴方向：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

正交投影

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

透视投影

在这里插入图片描述
齐次坐标的补充：
在这里插入图片描述
挤压+正交投影
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
远平面和近平面不变：利用两条件可以列出方程式求解
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
可视角：
在这里插入图片描述

屏幕空间

在这里插入图片描述
在这里插入图片描述

光栅化

在这里插入图片描述
在这里插入图片描述
显存控制：
在这里插入图片描述

三角形

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

判断一个点在三角形内

利用叉积！符号一致，在三角形内，否则在三角形外！
在这里插入图片描述

运算

用包围盒去简化
在这里插入图片描述
在这里插入图片描述

结果

在这里插入图片描述
在这里插入图片描述

反走样问题

采样理论

位置采样：
在这里插入图片描述
时间采样：
在这里插入图片描述

采样前先做模糊操作

在这里插入图片描述
注意：顺序不能反过来！
在这里插入图片描述

频域

在这里插入图片描述
傅里叶变换：
在这里插入图片描述
在这里插入图片描述

滤波

右图是频域图：最中心是低频，周围是会越来越高！在不同频率上存在的信息表示为亮度，这张图表示大部分信息都在低频中，高频信息比较少。
在这里插入图片描述
高通滤波器：
只有高频信号可以通过，提取出边界，在边界两侧信号发生剧烈变化，频率非常大。
在这里插入图片描述
低通滤波器：
低频率通过，看不到边界。
在这里插入图片描述
中通滤波：
中等频率通过.
在这里插入图片描述

filtering = convolution

在这里插入图片描述

实现了低通滤波：模糊处理
在这里插入图片描述

Sampling 采样

在这里插入图片描述
采样频率太低，发生重叠，导致结果走样：
在这里插入图片描述

解决方法

1.增加采样率
在这里插入图片描述
2.先模糊后采样
在这里插入图片描述
在这里插入图片描述

示例：
在这里插入图片描述

MSAA

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
代价：增大计算量，可以通过不规则分布，进行复用，提高利用率，减小计算率！
在这里插入图片描述

作业1

注意：openCV中默认是左上角为顶点，而传入的z又都是正值，在这里，我改为传入负值，与原视频中保持一致，同时改动了set_pixel的显示方式，理论上应该得到倒三角形，因为y轴方向相反！
main.cpp

#include "Triangle.hpp"
#include "rasterizer.hpp"
#include <eigen3/Eigen/Eigen>
#include <iostream>
#include <opencv4/opencv2/opencv.hpp>

constexpr double MY_PI = 3.1415926;

Eigen::Matrix4f get_view_matrix(Eigen::Vector3f eye_pos)
{
    Eigen::Matrix4f view = Eigen::Matrix4f::Identity();

    Eigen::Matrix4f translate;
    translate << 1, 0, 0, -eye_pos[0], 0, 1, 0, -eye_pos[1], 0, 0, 1,
        -eye_pos[2], 0, 0, 0, 1;

    view = translate * view;  

    return view;
}

Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    float theta = rotation_angle / 180.0 * M_PI;
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();
    model << std::cos(theta), -std::sin(theta), 0, 0,
        std::sin(theta), std::cos(theta), 0, 0,
        0, 0, 1.0, 0,
        0, 0, 0, 1;
    // TODO: Implement this function
    // Create the model matrix for rotating the triangle around the Z axis.
    // Then return it.

    return model;
}

Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar)
{
    // Students will implement this function

    Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();

    // TODO: Implement this function
    // Create the projection matrix for the given parameters.
    // Then return it.
    Eigen::Matrix4f p1 = Eigen::Matrix4f::Identity();
    p1 << zNear, 0, 0, 0,
        0, zNear, 0, 0,
        0, 0, zNear + zFar, -zFar * zNear,
        0, 0, 1.0, 0;
    float theta = eye_fov / 2.0 / 180.0 * M_PI;
    float y_top = -zNear * std::tan(theta);
    float x_left = -y_top * aspect_ratio;
    float x_right = -x_left;
    float y_down = -y_top;
    
    Eigen::Matrix4f scale = Eigen::Matrix4f::Identity();
    scale << 2.0 / (x_right - x_left), 0, 0, 0,
        0, 2.0 / (y_top - y_down), 0, 0,
        0, 0, 2.0 / (zNear - zFar), 0,
        0, 0, 0, 1.0;

    Eigen::Matrix4f trans = Eigen::Matrix4f::Identity();
    trans << 1, 0, 0, -(x_left + x_right) /2,
        0, 1, 0, -(y_top + y_down) / 2,
        0, 0, 1, -(zNear + zFar) / 2,
        0, 0, 0, 1;
    projection = scale * trans * p1;

    return projection;
}

int main(int argc, const char **argv)
{
    float angle = 0;
    bool command_line = false;
    std::string filename = "output.png";

    if (argc >= 3)
    {
        command_line = true;
        angle = std::stof(argv[2]); // -r by default
        if (argc == 4)
        {
            filename = std::string(argv[3]);
        }
        else
            return 0;
    }

    rst::rasterizer r(700, 700);

    Eigen::Vector3f eye_pos = {0, 0, 5};

    std::vector<Eigen::Vector3f> pos{{2, 0, -2}, {0, 2, -2}, {-2, 0, -2}};

    std::vector<Eigen::Vector3i> ind{{0, 1, 2}};

    auto pos_id = r.load_positions(pos);
    auto ind_id = r.load_indices(ind);

    int key = 0;
    int frame_count = 0;

    if (command_line)
    {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);

        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));

        r.draw(pos_id, ind_id, rst::Primitive::Triangle);
        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);

        cv::imwrite(filename, image);

        return 0;
    }

    while (key != 27)
    {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);

        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));

        r.draw(pos_id, ind_id, rst::Primitive::Triangle);

        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);
        cv::imshow("image", image);
        key = cv::waitKey(10);

        std::cout << "frame count: " << frame_count++ << '\n';

        if (key == 'a')
        {
            angle += 10;
        }
        else if (key == 'd')
        {
            angle -= 10;
        }
    }

    return 0;
}

rasterizer.cpp

//
// Created by goksu on 4/6/19.
//

#include <algorithm>
#include "rasterizer.hpp"
#include <opencv4/opencv2/opencv.hpp>
#include <math.h>
#include <stdexcept>


rst::pos_buf_id rst::rasterizer::load_positions(const std::vector<Eigen::Vector3f> &positions)
{
    auto id = get_next_id();
    pos_buf.emplace(id, positions);

    return {id};
}

rst::ind_buf_id rst::rasterizer::load_indices(const std::vector<Eigen::Vector3i> &indices)
{
    auto id = get_next_id();
    ind_buf.emplace(id, indices);

    return {id};
}

// Bresenham's line drawing algorithm
// Code taken from a stack overflow answer: https://stackoverflow.com/a/16405254
void rst::rasterizer::draw_line(Eigen::Vector3f begin, Eigen::Vector3f end)
{
    auto x1 = begin.x();
    auto y1 = begin.y();
    auto x2 = end.x();
    auto y2 = end.y();

    Eigen::Vector3f line_color = {255, 255, 255};

    int x,y,dx,dy,dx1,dy1,px,py,xe,ye,i;

    dx=x2-x1;
    dy=y2-y1;
    dx1=fabs(dx);
    dy1=fabs(dy);
    px=2*dy1-dx1;
    py=2*dx1-dy1;

    if(dy1<=dx1)
    {
        if(dx>=0)
        {
            x=x1;
            y=y1;
            xe=x2;
        }
        else
        {
            x=x2;
            y=y2;
            xe=x1;
        }
        Eigen::Vector3f point = Eigen::Vector3f(x, y, 1.0f);
        set_pixel(point,line_color);
        for(i=0;x<xe;i++)
        {
            x=x+1;
            if(px<0)
            {
                px=px+2*dy1;
            }
            else
            {
                if((dx<0 && dy<0) || (dx>0 && dy>0))
                {
                    y=y+1;
                }
                else
                {
                    y=y-1;
                }
                px=px+2*(dy1-dx1);
            }
//            delay(0);
            Eigen::Vector3f point = Eigen::Vector3f(x, y, 1.0f);
            set_pixel(point,line_color);
        }
    }
    else
    {
        if(dy>=0)
        {
            x=x1;
            y=y1;
            ye=y2;
        }
        else
        {
            x=x2;
            y=y2;
            ye=y1;
        }
        Eigen::Vector3f point = Eigen::Vector3f(x, y, 1.0f);
        set_pixel(point,line_color);
        for(i=0;y<ye;i++)
        {
            y=y+1;
            if(py<=0)
            {
                py=py+2*dx1;
            }
            else
            {
                if((dx<0 && dy<0) || (dx>0 && dy>0))
                {
                    x=x+1;
                }
                else
                {
                    x=x-1;
                }
                py=py+2*(dx1-dy1);
            }
//            delay(0);
            Eigen::Vector3f point = Eigen::Vector3f(x, y, 1.0f);
            set_pixel(point,line_color);
        }
    }
}

auto to_vec4(const Eigen::Vector3f& v3, float w = 1.0f)
{
    return Vector4f(v3.x(), v3.y(), v3.z(), w);
}

void rst::rasterizer::draw(rst::pos_buf_id pos_buffer, rst::ind_buf_id ind_buffer, rst::Primitive type)
{
    if (type != rst::Primitive::Triangle)
    {
        throw std::runtime_error("Drawing primitives other than triangle is not implemented yet!");
    }
    auto& buf = pos_buf[pos_buffer.pos_id];
    auto& ind = ind_buf[ind_buffer.ind_id];

    float f1 = (100 - 0.1) / 2.0;
    float f2 = (100 + 0.1) / 2.0;

    Eigen::Matrix4f mvp = projection * view * model;
    for (auto& i : ind)
    {
        Triangle t;

        Eigen::Vector4f v[] = {
                mvp * to_vec4(buf[i[0]], 1.0f),
                mvp * to_vec4(buf[i[1]], 1.0f),
                mvp * to_vec4(buf[i[2]], 1.0f)
        };

        for (auto& vec : v) {
            vec /= vec.w();
        }

        for (auto & vert : v)
        {
            vert.x() = 0.5*width*(vert.x()+1.0);
            vert.y() = 0.5*height*(vert.y()+1.0);
            vert.z() = vert.z() * f1 + f2;
        }

        for (int i = 0; i < 3; ++i)
        {
            t.setVertex(i, v[i].head<3>());
            t.setVertex(i, v[i].head<3>());
            t.setVertex(i, v[i].head<3>());
        }

        t.setColor(0, 255.0,  0.0,  0.0);
        t.setColor(1, 0.0  ,255.0,  0.0);
        t.setColor(2, 0.0  ,  0.0,255.0);

        rasterize_wireframe(t);
    }
}

void rst::rasterizer::rasterize_wireframe(const Triangle& t)
{
    draw_line(t.c(), t.a());
    draw_line(t.c(), t.b());
    draw_line(t.b(), t.a());
}

void rst::rasterizer::set_model(const Eigen::Matrix4f& m)
{
    model = m;
}

void rst::rasterizer::set_view(const Eigen::Matrix4f& v)
{
    view = v;
}

void rst::rasterizer::set_projection(const Eigen::Matrix4f& p)
{
    projection = p;
}

void rst::rasterizer::clear(rst::Buffers buff)
{
    if ((buff & rst::Buffers::Color) == rst::Buffers::Color)
    {
        std::fill(frame_buf.begin(), frame_buf.end(), Eigen::Vector3f{0, 0, 0});
    }
    if ((buff & rst::Buffers::Depth) == rst::Buffers::Depth)
    {
        std::fill(depth_buf.begin(), depth_buf.end(), std::numeric_limits<float>::infinity());
    }
}

rst::rasterizer::rasterizer(int w, int h) : width(w), height(h)
{
    frame_buf.resize(w * h);
    depth_buf.resize(w * h);
}

int rst::rasterizer::get_index(int x, int y)
{
    return (height-y)*width + x;
}

void rst::rasterizer::set_pixel(const Eigen::Vector3f& point, const Eigen::Vector3f& color)
{
    //old index: auto ind = point.y() + point.x() * width;
    if (point.x() < 0 || point.x() >= width ||
        point.y() < 0 || point.y() >= height) return;
    auto ind = point.y()*width + point.x();
    frame_buf[ind] = color;
}

效果图：在这里插入代码片
在这里插入图片描述

作业2

main.cpp

// clang-format off
#include <iostream>
#include <opencv2/opencv.hpp>
#include "rasterizer.hpp"
#include "global.hpp"
#include "Triangle.hpp"

constexpr double MY_PI = 3.1415926;

Eigen::Matrix4f get_view_matrix(Eigen::Vector3f eye_pos)
{
    Eigen::Matrix4f view = Eigen::Matrix4f::Identity();

    Eigen::Matrix4f translate;
    translate << 1,0,0,-eye_pos[0],
                 0,1,0,-eye_pos[1],
                 0,0,1,-eye_pos[2],
                 0,0,0,1;

    view = translate*view;

    return view;
}

Eigen::Matrix4f get_model_matrix(float rotation_angle)
{
    float theta = rotation_angle / 180.0 * M_PI;
    Eigen::Matrix4f model = Eigen::Matrix4f::Identity();
    model << std::cos(theta), -std::sin(theta), 0, 0,
        std::sin(theta), std::cos(theta), 0, 0,
        0, 0, 1.0, 0,
        0, 0, 0, 1;
    // TODO: Implement this function
    // Create the model matrix for rotating the triangle around the Z axis.
    // Then return it.

    return model;
}

Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio,
                                      float zNear, float zFar)
{
    // Students will implement this function

    Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();

    // TODO: Implement this function
    // Create the projection matrix for the given parameters.
    // Then return it.
    Eigen::Matrix4f p1 = Eigen::Matrix4f::Identity();
    p1 << zNear, 0, 0, 0,
        0, zNear, 0, 0,
        0, 0, zNear + zFar, -zFar * zNear,
        0, 0, 1.0, 0;
    float theta = eye_fov / 2.0 / 180.0 * M_PI;
    float y_top = -zNear * std::tan(theta);
    float x_left = -y_top * aspect_ratio;
    float x_right = -x_left;
    float y_down = -y_top;

    Eigen::Matrix4f scale = Eigen::Matrix4f::Identity();
    scale << 2.0 / (x_right - x_left), 0, 0, 0,
        0, 2.0 / (y_top - y_down), 0, 0,
        0, 0, 2.0 / (zNear - zFar), 0,
        0, 0, 0, 1.0;

    Eigen::Matrix4f trans = Eigen::Matrix4f::Identity();
    trans << 1, 0, 0, -(x_left + x_right) /2,
        0, 1, 0, -(y_top + y_down) / 2,
        0, 0, 1, -(zNear + zFar) / 2,
        0, 0, 0, 1;
    projection = scale * trans * p1;

    return projection;
}


int main(int argc, const char** argv)
{
    float angle = 0;
    bool command_line = false;
    std::string filename = "output.png";

    if (argc == 2)
    {
        command_line = true;
        filename = std::string(argv[1]);
    }

    rst::rasterizer r(700, 700);

    Eigen::Vector3f eye_pos = {0,0,5};


    std::vector<Eigen::Vector3f> pos 
            {
                    {2, 0, -2},
                    {0, 2, -2},
                    {-2, 0, -2},
                    {3.5, -1, -5},
                    {2.5, 1.5, -5},
                    {-1, 0.5, -5}
            };

    std::vector<Eigen::Vector3i> ind
            {
                    {0, 1, 2},
                    {3, 4, 5}
            };

    std::vector<Eigen::Vector3f> cols
            {
                    {217.0, 238.0, 185.0},
                    {217.0, 238.0, 185.0},
                    {217.0, 238.0, 185.0},
                    {185.0, 217.0, 238.0},
                    {185.0, 217.0, 238.0},
                    {185.0, 217.0, 238.0}
            };

    auto pos_id = r.load_positions(pos);
    auto ind_id = r.load_indices(ind);
    auto col_id = r.load_colors(cols);

    int key = 0;
    int frame_count = 0;

    if (command_line)
    {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);

        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));

        r.draw(pos_id, ind_id, col_id, rst::Primitive::Triangle);
        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);
        cv::cvtColor(image, image, cv::COLOR_RGB2BGR);

        cv::imwrite(filename, image);

        return 0;
    }

    while(key != 27)
    {
        r.clear(rst::Buffers::Color | rst::Buffers::Depth);

        r.set_model(get_model_matrix(angle));
        r.set_view(get_view_matrix(eye_pos));
        r.set_projection(get_projection_matrix(45, 1, 0.1, 50));

        r.draw(pos_id, ind_id, col_id, rst::Primitive::Triangle);

        cv::Mat image(700, 700, CV_32FC3, r.frame_buffer().data());
        image.convertTo(image, CV_8UC3, 1.0f);
        cv::cvtColor(image, image, cv::COLOR_RGB2BGR);
        cv::imshow("image", image);
        key = cv::waitKey(10);

        std::cout << "frame count: " << frame_count++ << '\n';
    }

    return 0;
}
// clang-format on

rasterizer.cpp

// clang-format off
//
// Created by goksu on 4/6/19.
//

#include <algorithm>
#include <vector>
#include "rasterizer.hpp"
#include <opencv2/opencv.hpp>
#include <math.h>


rst::pos_buf_id rst::rasterizer::load_positions(const std::vector<Eigen::Vector3f> &positions)
{
    auto id = get_next_id();
    pos_buf.emplace(id, positions);

    return {id};
}

rst::ind_buf_id rst::rasterizer::load_indices(const std::vector<Eigen::Vector3i> &indices)
{
    auto id = get_next_id();
    ind_buf.emplace(id, indices);

    return {id};
}

rst::col_buf_id rst::rasterizer::load_colors(const std::vector<Eigen::Vector3f> &cols)
{
    auto id = get_next_id();
    col_buf.emplace(id, cols);

    return {id};
}

auto to_vec4(const Eigen::Vector3f& v3, float w = 1.0f)
{
    return Vector4f(v3.x(), v3.y(), v3.z(), w);
}


static bool insideTriangle(float x, float y, const Vector3f* _v)
{   
    // TODO : Implement this function to check if the point (x, y) is inside the triangle represented by _v[0], _v[1], _v[2]
    Eigen::Vector2f p;
    p << x, y;

    Eigen::Vector2f AB = _v[1].head(2) - _v[0].head(2);
    Eigen::Vector2f BC = _v[2].head(2) - _v[1].head(2);
    Eigen::Vector2f CA = _v[0].head(2) - _v[2].head(2);

    Eigen::Vector2f AP = p - _v[0].head(2);
    Eigen::Vector2f BP = p - _v[1].head(2);
    Eigen::Vector2f CP = p - _v[2].head(2);

    return AB[0] * AP[1] - AB[1] * AP[0] >0 && 
    BC[0] * BP[1] - BC[1] * BP[0] >0 && 
    CA[0] * CP[1] - CA[1] * CP[0] >0;
}

static std::tuple<float, float, float> computeBarycentric2D(float x, float y, const Vector3f* v)
{
    float c1 = (x*(v[1].y() - v[2].y()) + (v[2].x() - v[1].x())*y + v[1].x()*v[2].y() - v[2].x()*v[1].y()) / (v[0].x()*(v[1].y() - v[2].y()) + (v[2].x() - v[1].x())*v[0].y() + v[1].x()*v[2].y() - v[2].x()*v[1].y());
    float c2 = (x*(v[2].y() - v[0].y()) + (v[0].x() - v[2].x())*y + v[2].x()*v[0].y() - v[0].x()*v[2].y()) / (v[1].x()*(v[2].y() - v[0].y()) + (v[0].x() - v[2].x())*v[1].y() + v[2].x()*v[0].y() - v[0].x()*v[2].y());
    float c3 = (x*(v[0].y() - v[1].y()) + (v[1].x() - v[0].x())*y + v[0].x()*v[1].y() - v[1].x()*v[0].y()) / (v[2].x()*(v[0].y() - v[1].y()) + (v[1].x() - v[0].x())*v[2].y() + v[0].x()*v[1].y() - v[1].x()*v[0].y());
    return {c1,c2,c3};
}

void rst::rasterizer::draw(pos_buf_id pos_buffer, ind_buf_id ind_buffer, col_buf_id col_buffer, Primitive type)
{
    auto& buf = pos_buf[pos_buffer.pos_id];
    auto& ind = ind_buf[ind_buffer.ind_id];
    auto& col = col_buf[col_buffer.col_id];

    float f1 = (50 - 0.1) / 2.0;
    float f2 = (50 + 0.1) / 2.0;

    Eigen::Matrix4f mvp = projection * view * model;
    for (auto& i : ind)
    {
        Triangle t;
        Eigen::Vector4f v[] = {
                mvp * to_vec4(buf[i[0]], 1.0f),
                mvp * to_vec4(buf[i[1]], 1.0f),
                mvp * to_vec4(buf[i[2]], 1.0f)
        };
        //Homogeneous division
        for (auto& vec : v) {
            vec /= vec.w();
        }
        //Viewport transformation
        for (auto & vert : v)
        {
            vert.x() = 0.5*width*(vert.x()+1.0);
            vert.y() = 0.5*height*(vert.y()+1.0);
            vert.z() = vert.z() * f1 + f2;
        }

        for (int i = 0; i < 3; ++i)
        {
            t.setVertex(i, v[i].head<3>());
            t.setVertex(i, v[i].head<3>());
            t.setVertex(i, v[i].head<3>());
        }

        auto col_x = col[i[0]];
        auto col_y = col[i[1]];
        auto col_z = col[i[2]];

        t.setColor(0, col_x[0], col_x[1], col_x[2]);
        t.setColor(1, col_y[0], col_y[1], col_y[2]);
        t.setColor(2, col_z[0], col_z[1], col_z[2]);

        rasterize_triangle(t);
    }
}

//Screen space rasterization
void rst::rasterizer::rasterize_triangle(const Triangle& t) {
    auto v = t.toVector4();
    // TODO : Find out the bounding box of current triangle.
    // iterate through the pixel and find if the current pixel is inside the triangle

    // If so, use the following code to get the interpolated z value.
    //auto[alpha, beta, gamma] = computeBarycentric2D(x, y, t.v);
    //float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
    //float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
    //z_interpolated *= w_reciprocal;

    // TODO : set the current pixel (use the set_pixel function) to the color of the triangle (use getColor function) if it should be painted.
    float x_min1 = std::min(v[0][0], std::min(v[1][0], v[2][0]));
    float x_max1 = std::max(v[0][0], std::max(v[1][0], v[2][0]));
    float y_min1 = std::min(v[0][1], std::min(v[1][1], v[2][1]));
    float y_max1 = std::max(v[0][1], std::max(v[1][1], v[2][1]));   

    int x_min = std::floor(x_min1);
    int x_max = std::ceil(x_max1);
    int y_min = std::floor(y_min1);
    int y_max = std::ceil(y_max1);

    bool MSAA = false;
    if(MSAA){
        std::vector<Eigen::Vector2f> pos = {
            {0.25, 0.25},
            {0.25,0.75},
            {0.75,0.25},
            {0.75,0.75}
        };
        for(int x = x_min; x <= x_max; ++x){
            for(int y = y_min; y <= y_max; ++y){
     
                float count = 0;
                float dep = FLT_MAX;
                for(int i = 0; i < 4; ++i){
                    if(insideTriangle((float)x + pos[i][0], (float)y + pos[i][1], t.v)){
                        count += 1.0;
                        auto tup = computeBarycentric2D((float)x + pos[i][0], (float)y + pos[i][1], t.v);
                        float alpha, beta, gamma;
                        std::tie(alpha, beta, gamma) = tup;
                        float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                        float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
                        z_interpolated *= w_reciprocal;
                        dep = std::min(dep, z_interpolated);
                    }
                }
                if(count){
                    if(depth_buf[get_index(x, y)] > dep){
                        Vector3f color = t.getColor() * count / 4.0;
                        Vector3f point;
                        point << x, y, dep;
                        depth_buf[get_index(x, y)] = dep;
                        set_pixel(point, color);
                    }
                }
            }
        }
    }
    else{
        for(int x = x_min; x <= x_max; ++x){
            for(int y = y_min; y <= y_max; ++y){
                if(insideTriangle(x, y, t.v)){
                        auto tup = computeBarycentric2D(x, y, t.v);
                        float alpha, beta, gamma;
                        std::tie(alpha, beta, gamma) = tup;
                        float w_reciprocal = 1.0/(alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
                        float z_interpolated = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
                        z_interpolated *= w_reciprocal;

                        if(depth_buf[get_index(x, y)] > z_interpolated){
                            Vector3f color = t.getColor();
                            Vector3f point;
                            point << x, y, z_interpolated;
                            depth_buf[get_index(x, y)] = z_interpolated;
                            set_pixel(point, color);
                        }
                }
            }
        }
    }
}

void rst::rasterizer::set_model(const Eigen::Matrix4f& m)
{
    model = m;
}

void rst::rasterizer::set_view(const Eigen::Matrix4f& v)
{
    view = v;
}

void rst::rasterizer::set_projection(const Eigen::Matrix4f& p)
{
    projection = p;
}

void rst::rasterizer::clear(rst::Buffers buff)
{
    if ((buff & rst::Buffers::Color) == rst::Buffers::Color)
    {
        std::fill(frame_buf.begin(), frame_buf.end(), Eigen::Vector3f{0, 0, 0});
    }
    if ((buff & rst::Buffers::Depth) == rst::Buffers::Depth)
    {
        std::fill(depth_buf.begin(), depth_buf.end(), std::numeric_limits<float>::infinity());
    }
}

rst::rasterizer::rasterizer(int w, int h) : width(w), height(h)
{
    frame_buf.resize(w * h);
    depth_buf.resize(w * h);
}

int rst::rasterizer::get_index(int x, int y)
{
    return (height-1-y)*width + x;
}

void rst::rasterizer::set_pixel(const Eigen::Vector3f& point, const Eigen::Vector3f& color)
{
    //old index: auto ind = point.y() + point.x() * width;
    auto ind = (height-1-point.y())*width + point.x();
    frame_buf[ind] = color;

}

// clang-format on

采用MSAA抗锯齿：
在这里插入图片描述
仔细看边界处：
在这里插入图片描述
不采用MSAA：
在这里插入图片描述
仔细看边界处：可以看到明显的锯齿！
在这里插入图片描述

zzh123353
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
games101pdf课件
04-05
这份资料详细介绍了计算机图形学在游戏制作中的应用，包括模型、视图、投影（MVP）变换、图形渲染管线、光栅化、光线追踪、物理模拟以及动画等多个关键领域。 首先，我们来深入了解一下MVP变换。在计算机图形学中，...
Games101--现代计算机图形学入门 作业3笔记(渲染管线、着色模型、双线性插值)
2201_75303014的博客
01-20 958
Games101作业3笔记(渲染管线、着色模型、双线性插值)
GAMES101复习：变换
最不正经的计算机专业学生
07-24 155
图形学复习：变换
计算机图形学【GAMES-101】2、光栅化(反走样、傅里叶变换、卷积)
记录值得记录的东西
12-01 5160
Lecture5~6 Rasterization回顾上一课补充Frustum视椎体描述MVP之后应该做什么[-1,1]^3^ to [0,width]x[0,height] 从盒子到屏幕 回顾上一课 补充Frustum视椎体描述 之前立方体的表示方式是：[b,t] [l,r] [f,n]这样的6个平面 如何定义透视投影的相机视椎体？ Vertical field-of-view(fovY) and aspect ratio ,通过这两个属性就可以算出其他属性了 如何通过fovY和aspect计算出近平面
GAMES101作业2-代码框架逐行理解(c++基础巩固)
qq_41835314的博客
05-06 3915
逐行对代码框架进行解释，以及回顾涉及到的每一个c++知识点，本人c++基础并不牢固，学习图形学的同时借此巩固知识。
GAMES101现代计算机图形学入门——光栅化成像之视图变换
qq_59153970的博客
09-30 341
GAMES101现代计算机图形学入门课程个人笔记，对应原视频中04节内容 在涵盖了课程内容基础上，在个人能力范围之内进行部分了拓展，包含作业的代码及实现思路
GAMES101-现代计算机图形学学习笔记（作业01）
06-04
本次作业的任务是填写一个旋转矩阵和一个透视投影矩阵。...我们需要进行模型、视图、投影、视口等变换来将三角形显示在屏幕上。在提供 的代码框架中，我们留下了模型变换和投影变换的部分给你去完成。
games101自用笔记
03-22
接下来，我们会学习图形管线，这是计算机图形渲染的基本流程，包括顶点处理（顶点着色器）、光栅化和像素处理（片段着色器）等阶段。在这个过程中，我们可能涉及到深度测试、裁剪、光照模型等内容，这些都是构建逼真...
GAMES101.rar
08-12
【标题】"GAMES101.rar"是一个压缩文件，很可能包含了与游戏开发相关的课程资料或项目源代码，其中的“GAMES101”可能是课程编号或者项目的代号，暗示了内容可能属于游戏设计与编程的基础教程。在这个压缩包中，我们...
GAMES101作业1.zip
11-25
【GAMES101作业1.zip】是一个与游戏开发相关的学习资源，可能包含了某课程GAMES101的作业内容，特别是针对提高题目的解答。这个压缩包可能包含学生的源代码、设计文档、分析报告或者其他的项目文件。GAMES101可能是...
games101作业1框架及解题办法详解
qq_51599283的博客
03-29 3675
所用到的函数1、Triangle.hppa,b,csetVertex()setNormal()setColor()setTexCoord()toVector4()2、Triangle.cpp3、rasterizer.hpp运算重载load_position()load_indices()set_model()set_view()set_projection()set_pixel()clear()draw()frame_buffer()draw_line()raster_wireframe()4、main.c
【GAMES101】作业2--三角形光栅化
beidou111的博客
06-10 3006
本文为GAMES101现代计算机图形学入门 的学习笔记系列。我们的系列笔记将分为两部分：原课程为2020年2月闫令琪所教授的 GAMES101 现代计算机图形学入门。课程主页：https://sites.cs.ucsb.edu/~lingqi/teaching/games101.html （幻灯片和课程录像均在此处）课程共计22节。作业共计8次。针对人群：计算机图形学入门新手教材： Steve Marschner and Peter Shirley的"Fundamentals of Computer Gra
GAMES101 作业2
m0_53161412的博客
02-22 622
GAMES101 作业2
GAMES101作业3-代码过程详细理解
qq_41835314的博客
05-09 4890
记录代码框架填补过程！以及总结涉及到的一些知识点内容，提高部分暂时没做。
【现代计算机图形学 GAMES101】 第五讲：光栅化（一）
动次打次动次打次
07-19 500
上节回顾 上节主要提到了观测变换 （Viewing transformation）, 其中包括了视图变换和投影变换。所谓的视图变换就是利用摄像机和物体的相对位置关系，始终把摄像机从任意一个位置移动到经典的原点位置，看向-z，并且向上方向是+y。并且保持其他物体和摄像机一样的移动。此时，我们就可以得到所有的物体都是由一个标准位置的相机看过去的，此时我们要做的就是把它从三维投影到二维。投影分为正交投影和透视投影。 区别： 正交投影：把深度信息忽略，假设相机放的无限远 透视投影：我们可以获得一个近大远小的效果
光栅化的深入理解
热门推荐
Wait的专栏
08-19 1万+
原文http://msdn.microsoft.com/en-us/bb219690(v=vs.85)或http://msdn.microsoft.com/en-us/ee417850%28VS.85%29.aspx When rendering 2D output using pre-transformed vertices, care must be taken to ensure that
GAMES101-现代计算机图形学学习笔记（3）作业2
糯米
07-26 2473
前言 上篇作业1 本篇继续更新作业2相关。 作业2相关链接 games的作业2链接 我的源码 作业2简述 在作业1的基础上栅格化一个三角形 判断点是否在三角形内 （提高）使用Supersampling抗锯齿 作业2相关知识笔记 光栅化算法:如何构建一个三角形的BoundingBox Depth buffer（Z-Buffering） Antialising Supersampling(MSAA) 作业2思路 注意：后面有代码展示，一定要自己先做一遍再看，而且我的设计不一定正确规范高效。 构建三角
games101作业2解题办法详解
qq_51599283的博客
03-31 1979
作业2的整体代码框架和作业1相同，不同点在于这次需要绘制的是实心的三角形，且两个三角形之间有重叠，所以需要做深度检测。 这是此次作业的要求。 首先来实现三角形的栅格化算法函数 rasterize_triangle(const Triangle& t) 在给定的作业要求pdf中已经给了具体的算法，我们只需要将算法转换成代码即可。 1、首先需要建立三角形的bounding box，这个box就是一个二维的矩形，是可以把三角形包围起来的最小矩形 auto v = t.toVector4()
games101 光栅化
最新发布
07-28
光栅化是将图形对象转换为屏幕上的像素的过程。它是图形管道中的关键操作，通过枚举基元覆盖的像素并在基元上插值属性，将基元转化为一组片段，每个片段对应于基元覆盖的像素。光栅化的目的是将物体呈现在屏幕上，使其可见。在光栅化过程中，需要进行采样、走样消除和反走样等操作，以提高图像的质量。总结一下光栅化的步骤：采样->走样(无法避免，只能消除)->反走样。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* [Games101计算机图形学入门基础之二：光栅化](https://blog.csdn.net/superheromen/article/details/126010745)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* *3* [【计算机图形学】【GAMES101学习笔记】Rasterization 光栅化](https://blog.csdn.net/charenCsdn/article/details/125854534)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值