• 【GAMES101 作业3】渲染小奶牛+使用.obj模型+双线性插值+踩坑总结

    目录

    一、渲染小奶牛

    1. normal shader

    get_projection_matrix （来自作业1，填充在main.cpp中）

    rasterize_triangle（来自作业2，填充在rasterizer.cpp中）

    2. phong shader

    phong_fragment_shader（填充在main.cpp中）

    3. texture shader

    texture_fragment_shader（填充在main.cpp中）

    4. bump shader

    bump_fragment_shader（填充在main.cpp中）

    4. displacement shader

    displacement_fragment_shader（填充在main.cpp中）

    二、使用.obj模型

    三、双线性插值

    四、踩坑总结

    一、渲染小奶牛

    1. normal shader

    根据官方教程，我们需要使用 作业1、作业2 里面实现的代码来填充以下两个函数，并得到样例normal shader的渲染结果：

    • get_projection_matrix （来自作业1，填充在main.cpp中）

    1. // TODO: Use the same projection matrix from the previous assignments
    2. Eigen::Matrix4f get_projection_matrix(float eye_fov, float aspect_ratio, float zNear, float zFar)
    3. {
    4.     Eigen::Matrix4f projection = Eigen::Matrix4f::Identity();
    5.     Eigen::Matrix4f M_p = Eigen::Matrix4f::Identity();
    6.     M_p << zNear,0,0,0,
    7.                0,zNear,0,0,
    8.                0,0,zNear+zFar,(-1.0*zNear*zFar),
    9.                0,0,1,0;
    10.     //[l,r]   [b,t]    [f,n]
    11.     float angle = eye_fov*MY_PI/180;
    12.     float t = tan(angle/2)*-zNear;
    13.     float b = -1.0*t;
    14.     float r = t*aspect_ratio;
    15.     float l = -1.0*r;
    16.  
    17.     Eigen::Matrix4f M_s = Eigen::Matrix4f::Identity();
    18.     M_s <<  2/(r-l),0,0,0,
    19.             0,2/(t-b),0,0,
    20.             0,0,2/(zNear-zFar),0,
    21.             0,0,0,1;
    22.                
    23.     Eigen::Matrix4f M_t = Eigen::Matrix4f::Identity();
    24.     M_t <<  1,0,0,(-1.0)*(r+l)/2,
    25.             0,1,0,(-1.0)*(t+b)/2,
    26.             0,0,1,(-1.0)*(zNear+zFar)/2,
    27.             0,0,0,1;
    28.     
    29.     projection = M_s*M_t*M_p*projection;
    30.  
    31.     return projection;
    32. }

    • rasterize_triangle（来自作业2，填充在rasterizer.cpp中）

    1. // my func
    2. float min2(float a, float b) {
    3.     if (a < b) return a;
    4.     else return b;
    5. }
    6.  
    7. // my func
    8. float min3(float a, float b, float c) {
    9.     return min2(min2(a,b), c);
    10. }
    11.  
    12. // my func
    13. float max2(float a, float b) {
    14.     if (a > b) return a;
    15.     else return b;
    16. }
    17.  
    18. // my func
    19. float max3(float a, float b, float c) {
    20.     return max2(max2(a,b), c);
    21. }
    22.  
    23. //Screen space rasterization
    24. void rst::rasterizer::rasterize_triangle(const Triangle& t, const std::array3>& view_pos) 
    25. {
    26.     auto v = t.toVector4();
    27.     const Eigen::Vector4f _v[3] = {
    28.         {v[0].x(), v[0].y(), v[0].z(), v[0].w()},
    29.         {v[1].x(), v[1].y(), v[1].z(), v[1].w()},
    30.         {v[2].x(), v[2].y(), v[2].z(), v[2].w()}
    31.     };
    32.     
    33.     // TODO : Find out the bounding box of current triangle.
    34.     int x_min = (int) (min3(v[0].x(), v[1].x(), v[2].x())/1.0) -1;
    35.     int x_max = (int) (max3(v[0].x(), v[1].x(), v[2].x())/1.0) +1;
    36.     int y_min = (int) (min3(v[0].y(), v[1].y(), v[2].y())/1.0) -1;
    37.     int y_max = (int) (max3(v[0].y(), v[1].y(), v[2].y())/1.0) +1;
    38.  
    39.     // iterate through the pixel and find if the current pixel is inside the triangle.
    40.     for (int x = x_min-1; x < x_max; ++x) {
    41.         for (int y = y_min-1; y < y_max; ++y) {
    42.             if (insideTriangle(x+0.5, y+0.5, _v)) {
    43.                 // If so, use the following code to get the interpolated z value.
    44.                 auto[alpha, beta, gamma] = computeBarycentric2D(x, y, t.v);
    45.  
    46.                 // Z is interpolated view space depth for the current pixel
    47.                 float Z = 1.0 / (alpha / v[0].w() + beta / v[1].w() + gamma / v[2].w());
    48.                 float zp = alpha * v[0].z() / v[0].w() + beta * v[1].z() / v[1].w() + gamma * v[2].z() / v[2].w();
    49.                 zp *= Z; // zp is for z-buffer
    50.  
    51.                 auto ind = get_index(x, y);
    52.                 if (ind < width * height && zp < depth_buf[ind]) {
    53.  
    54.                     depth_buf[ind] = zp; // update z-buffer
    55.                     
    56.                     // TODO: Interpolate the attributes:
    57.                     auto interpolated_color = alpha*t.color[0] + beta*t.color[1] + gamma*t.color[2];
    58.                     auto interpolated_normal = alpha*t.normal[0] + beta*t.normal[1] + gamma*t.normal[2];
    59.                     auto interpolated_texcoords = alpha*t.tex_coords[0] + beta*t.tex_coords[1] + gamma*t.tex_coords[2];
    60.  
    61.                     auto interpolated_shadingcoords = interpolate(alpha, beta, gamma, view_pos[0], view_pos[1], view_pos[2], 1);
    62.  
    63.                     fragment_shader_payload payload(interpolated_color, interpolated_normal.normalized(), interpolated_texcoords, texture ? &*texture : nullptr);
    64.                     payload.view_pos = interpolated_shadingcoords;
    65.                     auto pixel_color = fragment_shader(payload);
    66.  
    67.                     // TODO : set the current pixel (use the set_pixel function) to the color of the triangle (use getColor function) if it should be painted.
    68.                     Eigen::Vector2i point(x, y); // the point of the pixel
    69.                     set_pixel(point, pixel_color);
    70.                 }
    71.             }
    72.         }
    73.     }
    74. }

    然后在项目文件夹中使用如下指令：

    1. mkdir build
    2. cd build
    3. cmake ..
    4. make
    5. ./Rasterizer normal.png normal

    即可看到normal shader渲染结果：

    normal shader 渲染结果

    2. phong shader

    • phong_fragment_shader（填充在main.cpp中）

    这里要注意一个点，ka kd ks这些系数与后面的变量相乘都是使用 cwiseProduct() 方法，其作用为矩阵点对点相乘，因为这些系数都是表示颜色的（R,G,B）三维向量，而不是常数。

    1. Eigen::Vector3f phong_fragment_shader(const fragment_shader_payload& payload)
    2. {
    3.     Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    4.     Eigen::Vector3f kd = payload.color;
    5.     Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
    6.  
    7.     auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    8.     auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
    9.  
    10.     std::vector lights = {l1, l2};
    11.     Eigen::Vector3f amb_light_intensity{10, 10, 10};
    12.     Eigen::Vector3f eye_pos{0, 0, 10};
    13.  
    14.     float p = 150;
    15.  
    16.     Eigen::Vector3f color = payload.color;
    17.     Eigen::Vector3f point = payload.view_pos;
    18.     Eigen::Vector3f normal = payload.normal;
    19.  
    20.     Eigen::Vector3f result_color = {0, 0, 0};
    21.     for (auto& light : lights)
    22.     {   
    23.         // TODO: For each light source in the code, calculate what the *ambient*, *diffuse*, and *specular* components are.
    24.         Eigen::Vector3f light_dir = (light.position - point).normalized();
    25.         Eigen::Vector3f view_dir = (eye_pos - point).normalized();
    26.         Eigen::Vector3f half_vector = (light_dir + view_dir).normalized();
    27.  
    28.         // distance r^2
    29.         float r2 = (light.position - point).dot(light.position - point);
    30.  
    31.         // ambient
    32.         Eigen::Vector3f La = ka.cwiseProduct(amb_light_intensity); //cwiseProduct()：矩阵点对点相乘
    33.  
    34.         // diffuse
    35.         Eigen::Vector3f Ld = kd.cwiseProduct(light.intensity / r2);
    36.         Ld *= std::max(0.0f, normal.normalized().dot(light_dir));
    37.  
    38.         // specular
    39.         Eigen::Vector3f Ls = ks.cwiseProduct(light.intensity / r2);
    40.         Ls *= std::pow(std::max(0.0f, normal.normalized().dot(half_vector)), p);
    41.  
    42.         // Then, accumulate that result on the *result_color* object.
    43.         result_color += (La + Ld + Ls);
    44.     }
    45.  
    46.     return result_color * 255.f;
    47. }

    然后在项目文件夹中使用如下指令：

    1. mkdir build
    2. cd build
    3. cmake ..
    4. make
    5. ./Rasterizer phong.png phong

    即可看到phong shader渲染结果：

     phong shader 渲染结果

    3. texture shader

    • texture_fragment_shader（填充在main.cpp中）

    1. Eigen::Vector3f texture_fragment_shader(const fragment_shader_payload& payload)
    2. {
    3.     Eigen::Vector3f return_color = {0, 0, 0};
    4.     if (payload.texture)
    5.     {
    6.         // TODO: Get the texture value at the texture coordinates of the current fragment
    7.         return_color = payload.texture->getColor(payload.tex_coords.x(), payload.tex_coords.y());
    8.     }
    9.     Eigen::Vector3f texture_color;
    10.     texture_color << return_color.x(), return_color.y(), return_color.z();
    11.  
    12.     Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    13.     Eigen::Vector3f kd = texture_color / 255.f; // change kd to texture color, compared to phong shader
    14.     Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
    15.  
    16.     auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    17.     auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
    18.  
    19.     std::vector lights = {l1, l2};
    20.     Eigen::Vector3f amb_light_intensity{10, 10, 10};
    21.     Eigen::Vector3f eye_pos{0, 0, 10};
    22.  
    23.     float p = 150;
    24.  
    25.     Eigen::Vector3f color = texture_color;
    26.     Eigen::Vector3f point = payload.view_pos;
    27.     Eigen::Vector3f normal = payload.normal;
    28.  
    29.     Eigen::Vector3f result_color = {0, 0, 0};
    30.  
    31.     for (auto& light : lights)
    32.     {
    33.         // TODO: For each light source in the code, calculate what the *ambient*, *diffuse*, and *specular* components are.
    34.         Eigen::Vector3f light_dir = (light.position - point).normalized();
    35.         Eigen::Vector3f view_dir = (eye_pos - point).normalized();
    36.         Eigen::Vector3f half_vector = (light_dir + view_dir).normalized();
    37.  
    38.         // distance r^2
    39.         float r2 = (light.position - point).dot(light.position - point);
    40.  
    41.         // ambient
    42.         Eigen::Vector3f La = ka.cwiseProduct(amb_light_intensity); //cwiseProduct()：矩阵点对点相乘
    43.  
    44.         // diffuse
    45.         Eigen::Vector3f Ld = kd.cwiseProduct(light.intensity / r2);
    46.         Ld *= std::max(0.0f, normal.normalized().dot(light_dir));
    47.  
    48.         // specular
    49.         Eigen::Vector3f Ls = ks.cwiseProduct(light.intensity / r2);
    50.         Ls *= std::pow(std::max(0.0f, normal.normalized().dot(half_vector)), p);
    51.  
    52.         // Then, accumulate that result on the *result_color* object.
    53.         result_color += (La + Ld + Ls);
    54.     }
    55.  
    56.     return result_color * 255.f;
    57. }

    然后在项目文件夹中使用如下指令：

    1. mkdir build
    2. cd build
    3. cmake ..
    4. make
    5. ./Rasterizer texture.png texture

    即可看到phong shader渲染结果：

     texture shader 渲染结果

    4. bump shader

    • bump_fragment_shader（填充在main.cpp中）

    这里有一点坑，此处参考了大佬的文章：

    Games101-作业3 - 知乎

    大体来说，通过改变物体表面的法线朝向而不是改变物体的体积来实现细小的凹凸不平的效果，所以bump mapping译作凹凸贴图。

    需注意的是 h(u, v) 的实现方法：

    1. Eigen::Vector3f bump_fragment_shader(const fragment_shader_payload& payload)
    2. {
    3.     
    4.     Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    5.     Eigen::Vector3f kd = payload.color;
    6.     Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
    7.  
    8.     auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    9.     auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
    10.  
    11.     std::vector lights = {l1, l2};
    12.     Eigen::Vector3f amb_light_intensity{10, 10, 10};
    13.     Eigen::Vector3f eye_pos{0, 0, 10};
    14.  
    15.     float p = 150;
    16.  
    17.     Eigen::Vector3f color = payload.color; 
    18.     Eigen::Vector3f point = payload.view_pos;
    19.     Eigen::Vector3f normal = payload.normal;
    20.  
    21.  
    22.     float kh = 0.2, kn = 0.1;
    23.  
    24.     // TODO: Implement bump mapping here
    25.     // Let n = normal = (x, y, z)
    26.     // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
    27.     float x = normal.x(), y = normal.y(), z = normal.z();
    28.     Eigen::Vector3f t(
    29.         x*y/sqrt(x*x+z*z),
    30.         sqrt(x*x+z*z),
    31.         z*y/sqrt(x*x+z*z)
    32.     );
    33.     // Vector b = n cross product t
    34.     Eigen::Vector3f b = normal.cross(t);
    35.     // Matrix TBN = [t b n]
    36.     Eigen::Matrix3f TBN;
    37.     TBN <<  t.x(), b.x(), normal.x(),
    38.             t.y(), b.y(), normal.y(),
    39.             t.z(), b.z(), normal.z();
    40.     // dU = kh * kn * (h(u+1/w,v)-h(u,v))
    41.     // dV = kh * kn * (h(u,v+1/h)-h(u,v))
    42.     float u = payload.tex_coords.x(), v = payload.tex_coords.y();
    43.     float w = payload.texture->width, h = payload.texture->height;
    44.     float dU = kh * kn * (payload.texture->getColor(u+1.0/w,v).norm() - payload.texture->getColor(u,v).norm());
    45.     float dV = kh * kn * (payload.texture->getColor(u,v+1/h).norm() - payload.texture->getColor(u,v).norm());
    46.     // Vector ln = (-dU, -dV, 1)
    47.     Eigen::Vector3f ln(-dU, -dV, 1.0f);
    48.     // Normal n = normalize(TBN * ln)
    49.     normal = (TBN * ln).normalized();
    50.  
    51.     Eigen::Vector3f result_color = {0, 0, 0};
    52.     result_color = normal;
    53.  
    54.     return result_color * 255.f;
    55. }

    然后在项目文件夹中使用如下指令：

    1. mkdir build
    2. cd build
    3. cmake ..
    4. make
    5. ./Rasterizer bump.png bump

    即可看到bump shader渲染结果：

     bump shader 渲染结果

    4. displacement shader

    • displacement_fragment_shader（填充在main.cpp中）

    1. Eigen::Vector3f displacement_fragment_shader(const fragment_shader_payload& payload)
    2. {
    3.     
    4.     Eigen::Vector3f ka = Eigen::Vector3f(0.005, 0.005, 0.005);
    5.     Eigen::Vector3f kd = payload.color;
    6.     Eigen::Vector3f ks = Eigen::Vector3f(0.7937, 0.7937, 0.7937);
    7.  
    8.     auto l1 = light{{20, 20, 20}, {500, 500, 500}};
    9.     auto l2 = light{{-20, 20, 0}, {500, 500, 500}};
    10.  
    11.     std::vector lights = {l1, l2};
    12.     Eigen::Vector3f amb_light_intensity{10, 10, 10};
    13.     Eigen::Vector3f eye_pos{0, 0, 10};
    14.  
    15.     float p = 150;
    16.  
    17.     Eigen::Vector3f color = payload.color; 
    18.     Eigen::Vector3f point = payload.view_pos;
    19.     Eigen::Vector3f normal = payload.normal;
    20.  
    21.     float kh = 0.2, kn = 0.1;
    22.     
    23.     // Let n = normal = (x, y, z)
    24.     // Vector t = (x*y/sqrt(x*x+z*z),sqrt(x*x+z*z),z*y/sqrt(x*x+z*z))
    25.     float x = normal.x(), y = normal.y(), z = normal.z();
    26.     Eigen::Vector3f t(
    27.         x*y/sqrt(x*x+z*z),
    28.         sqrt(x*x+z*z),
    29.         z*y/sqrt(x*x+z*z)
    30.     );
    31.     // Vector b = n cross product t
    32.     Eigen::Vector3f b = normal.cross(t);
    33.     // Matrix TBN = [t b n]
    34.     Eigen::Matrix3f TBN;
    35.     TBN <<  t.x(), b.x(), normal.x(),
    36.             t.y(), b.y(), normal.y(),
    37.             t.z(), b.z(), normal.z();
    38.     // dU = kh * kn * (h(u+1/w,v)-h(u,v))
    39.     // dV = kh * kn * (h(u,v+1/h)-h(u,v))
    40.     float u = payload.tex_coords.x(), v = payload.tex_coords.y();
    41.     float w = payload.texture->width, h = payload.texture->height;
    42.     float dU = kh * kn * (payload.texture->getColor(u+1.0/w,v).norm() - payload.texture->getColor(u,v).norm());
    43.     float dV = kh * kn * (payload.texture->getColor(u,v+1/h).norm() - payload.texture->getColor(u,v).norm());
    44.     // Vector ln = (-dU, -dV, 1)
    45.     Eigen::Vector3f ln(-dU, -dV, 1.0f);
    46.     // Position p = p + kn * n * h(u,v)
    47.     point = point + kn * normal * payload.texture->getColor(u,v).norm();
    48.     // Normal n = normalize(TBN * ln)
    49.     normal = (TBN * ln).normalized();
    50.  
    51.     Eigen::Vector3f result_color = {0, 0, 0};
    52.  
    53.     for (auto& light : lights)
    54.     {
    55.         // TODO: For each light source in the code, calculate what the *ambient*, *diffuse*, and *specular* components are.
    56.         Eigen::Vector3f light_dir = (light.position - point).normalized();
    57.         Eigen::Vector3f view_dir = (eye_pos - point).normalized();
    58.         Eigen::Vector3f half_vector = (light_dir + view_dir).normalized();
    59.  
    60.         // distance r^2
    61.         float r2 = (light.position - point).dot(light.position - point);
    62.  
    63.         // ambient
    64.         Eigen::Vector3f La = ka.cwiseProduct(amb_light_intensity); //cwiseProduct()：矩阵点对点相乘
    65.  
    66.         // diffuse
    67.         Eigen::Vector3f Ld = kd.cwiseProduct(light.intensity / r2);
    68.         Ld *= std::max(0.0f, normal.normalized().dot(light_dir));
    69.  
    70.         // specular
    71.         Eigen::Vector3f Ls = ks.cwiseProduct(light.intensity / r2);
    72.         Ls *= std::pow(std::max(0.0f, normal.normalized().dot(half_vector)), p);
    73.  
    74.         // Then, accumulate that result on the *result_color* object.
    75.         result_color += (La + Ld + Ls);
    76.     }
    77.  
    78.     return result_color * 255.f;
    79. }

    然后在项目文件夹中使用如下指令：

    1. mkdir build
    2. cd build
    3. cmake ..
    4. make
    5. ./Rasterizer displacement.png displacement

    即可看到displacement shader渲染结果：

     displacement shader 渲染结果

     到这里基础部分已经全部做完！

    二、使用.obj模型

    这里还是参考大佬的文章：

    Games101｜作业3 + shading + 双线性插值 + 疑惑 - 知乎

    重点如下：

     其中提到了meshlab，在虚拟机ubuntu系统中直接搜索就能安装了：

    然后按照大佬前面说的步骤，将.obj文件载入并添加一些变量就行。

    最后修改main.cpp中对应的文件路径、贴图路径即可。

    下面是我做的效果图（bunny.obj）：（texture那里换了一张卡比的贴图，欸嘿~）

    三、双线性插值

    这里参考了大佬：

    GAMES101-现代计算机图形学学习笔记（作业03）_CCCCCCros____的博客-CSDN博客_games101 作业3

    需要注意的是，不同于我们往常使用的XY坐标轴，opencv图像中的坐标轴是这样的：

    在这里插入图片描述

     所以需要先经过 v' = 1 - v 转换后才能取颜色值！

    先在Texture.hpp里面加一句：

    然后在Texture.cpp中实现如下函数：

    1. //
    2. // Created by LEI XU on 4/27/19.
    3. //
    4.  
    5. #include "Texture.hpp"
    6. #include "global.hpp"
    7. #include 
    8. #include 
    9.  
    10. // my func
    11. cv::Vec3b lerp(float x, cv::Vec3b v0, cv::Vec3b v1)
    12. {
    13.     return v0 + x*(v1-v0);
    14. };
    15.  
    16. // my func
    17. float adjust_by_range(float x, float x_min, float x_max)
    18. {
    19.     if (x < x_min) return x_min;
    20.     if (x > x_max) return x_max;
    21.     return x;
    22. };
    23.  
    24. Eigen::Vector3f Texture::getColor(float u, float v)
    25. {
    26.     // 防止数组越界
    27.     u = adjust_by_range(u, 0, 1.0f);
    28.     v = adjust_by_range(v, 0, 1.0f);
    29.  
    30.     auto u_img = u * (width - 1);
    31.     auto v_img = (1 - v) * (height-1);
    32.     auto color = image_data.at(v_img, u_img);
    33.     return Eigen::Vector3f(color[0], color[1], color[2]);
    34. }
    35.  
    36. Eigen::Vector3f Texture::getColorBilinear(float u,float v)
    37. {
    38.     // 防止数组越界
    39.     u = adjust_by_range(u, 0, 1.0f);
    40.     v = adjust_by_range(v, 0, 1.0f);
    41.  
    42.     // height和width都-1是指数组从0开始    
    43.     float u_img = u * (width - 1);
    44.     float v_img = (1 - v) * (height - 1);
    45.  
    46.     float u_min = std::floor(u_img);
    47.     float u_max = std::ceil(u_img);
    48.     float v_min = std::floor(v_img);
    49.     float v_max = std::ceil(v_img);
    50.  
    51.     // auto color = image_data.at(v_img, u_img);
    52.     auto u00 = image_data.at(v_min, u_min);
    53.     auto u10 = image_data.at(v_min, u_max);
    54.     auto u01 = image_data.at(v_max, u_min);
    55.     auto u11 = image_data.at(v_max, u_max);
    56.  
    57.     float s = (u_img - u_min) / (u_max - u_min);
    58.     float t = (v_img - v_min) / (v_max - v_min);
    59.  
    60.     auto u0 = lerp(s, u00, u10);
    61.     auto u1 = lerp(s, u01, u11);
    62.  
    63.     auto result = lerp(t, u0, u1);
    64.     
    65.     return Eigen::Vector3f(result[0], result[1], result[2]);
    66. };

    使用以下网站压缩小奶牛的图片，为了效果明显，我压缩到100*100：

    图片压缩 - 在线工具 - OKTools

    然后记得替换main.cpp中的文件路径：

    得到结果如下：

    使用双线性插值前（100*100） 

    使用双线性插值后（100*100） 

    可以看见，插值前小奶牛的纹路边缘较为锋利，像素感比较明显；而插值后的像素感（尤其是眼睛、鼻子处）明显减弱了很多，出现了预料中的与周围颜色平均的结果。

    四、踩坑总结

    记得检查数组越界！！！记得检查数组越界！！！记得检查数组越界！！！

    否则在模型超出opencv的窗口大小（width*height）的时候，容易报错（core dumped）！

    1）在rasterizer类中，depth_buf（存储深度值的数组）和frame_buf（存储像素颜色的数组）是容易产生越界的，检查方法为 ：

    ① 在z value存入depth_buf之前先检查get_index函数的返回值ind是否越界，即使用如下语句：

             

    ② 在frame_buf的修改函数set_pixel中设置数组越界检查：

             

    2）在Texture类中增加如下代码，限制(u, v)越界（u, v的范围应为0~1）：

  • 相关阅读:
    OpenCV 环境变量参考
    Java实现Excel数据导入数据库
    ubuntu默认关联程序
    Ubuntu 22.04 (WSL2) 安装 libssl1.1
    LinkedList和链表
    Linux--ssh基本操作与配置
    微服务简介
    面试题：Java序列化与反序列化
    UVa11887 Tetrahedrons and Spheres
    【PowerQuery】Excel和PowerBI的PowerQuery 数据刷新
  • 原文地址：https://blog.csdn.net/onion23/article/details/126456501