计算机图形学头歌实训平台光照着色答案

最新推荐文章于 2024-08-14 22:49:08 发布
最新推荐文章于 2024-08-14 22:49:08 发布
阅读量316 收藏 5
点赞数 1
分类专栏： 计算机图形学头歌实训平台答案 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74822776/article/details/135224561
版权

第1关：均匀着色-随机颜色填充

#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 barycentric(Vec3f *pts, Vec3f P)
{
    Vec3f u = Vec3f(pts[2].x - pts[0].x, pts[1].x - pts[0].x, pts[0].x - P.x) ^
        Vec3f(pts[2].y - pts[0].y, pts[1].y - pts[0].y, pts[0].y - P.y);
    /* `pts` and `P` has integer value as coordinates
       so `abs(u[2])` < 1 means `u[2]` is 0, that means
       triangle is degenerate, in this case return something with negative coordinates */
    if (std::abs(u.z) < 1)
        return Vec3f(-1, 1, 1);
    return Vec3f(1.f - (u.x + u.y) / u.z, u.y / u.z, u.x / u.z);
}
void triangle(Vec3f *pts, float *zbuffer, PNGImage &image, PNGColor color)
{
    int minX = min({ pts[0].x, pts[1].x, pts[2].x });
    int maxX = max({ pts[0].x, pts[1].x, pts[2].x });
    int minY = min({ pts[0].y, pts[1].y, pts[2].y });
    int maxY = max({ pts[0].y, pts[1].y, pts[2].y });
    int width = image.get_width();
    int height = image.get_height();
    if (maxX >= width)
        maxX = width - 1;
    if (maxY >= height)
        maxY = height - 1;
    Vec3f P;
    for (P.x = minX; P.x <= maxX; P.x++) {
        for (P.y = minY; P.y <= maxY; P.y++) {
            Vec3f bc_screen = barycentric(pts, P);
            if (bc_screen.x < 0 || bc_screen.y < 0 || bc_screen.z < 0) continue;
            P.z = 0;
            for (int i = 0; i < 3; i++)
                P.z += pts[i].z * bc_screen[i];
            if (zbuffer[int(P.x + P.y*width)] < P.z) {
                zbuffer[int(P.x + P.y*width)] = P.z;
                image.set(P.x, P.y, color);
            }
        }
    }
}
Matrix projection(Vec3f eye, Vec3f center)
{
    Matrix m = Matrix::identity(4);
    m[3][2] = -1.f / (eye - center).norm();
    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 lookat(Vec3f eye, Vec3f center, Vec3f up) {
    Vec3f z = (eye - center).normalize();
    Vec3f x = (up^z).normalize();
    Vec3f y = (z^x).normalize();
    Matrix res = Matrix::identity(4);
    for (int i = 0; i < 3; i++) {
        res[0][i] = x[i];
        res[1][i] = y[i];
        res[2][i] = z[i];
        res[i][3] = -center[i];
    }
    return res;
}
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);
    const PNGColor orange = PNGColor(255, 128, 0, 255);
    const PNGColor clr[6] = {green, yellow, blue, red, white, orange};
    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("african_head.obj");
    float *zbuffer = new float[width*height];
    for (int i = 0; i < width * height; i++)
        zbuffer[i] = -numeric_limits<float>::max();
    // 请补充代码，添加合适的参数
    /********** Begin ********/
    Vec3f eye(0, 0, 4),center(0, 0, 0), up(0, 1, 0);
    Matrix ModelView = lookat(eye, center, up) * rotation_y(15);
    /********** End **********/
    Matrix Projection = projection(eye, center);
    Matrix ViewPort = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        vector<int> face = model->face(i);
            Vec3f triangleVertex[3];
            for (int j = 0; j < 3; j++)
            {
                Vec3f v1 = model->vert(face[j]);
                triangleVertex[j] = ViewPort * Projection * ModelView * v1;
            }
            // 请补充代码，其中每个面颜色随机生成
            /********** Begin ********/
            triangle(triangleVertex, zbuffer, image, PNGColor(rand() % 255, rand() % 255, rand() % 255, 255));
            /********** End **********/
    }
    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;
    delete zbuffer;
    return 0;
}

第2关：均匀着色-由面的法线向量计算光强

#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 barycentric(Vec3f *pts, Vec3f P)
{
    Vec3f u = Vec3f(pts[2].x - pts[0].x, pts[1].x - pts[0].x, pts[0].x - P.x) ^
        Vec3f(pts[2].y - pts[0].y, pts[1].y - pts[0].y, pts[0].y - P.y);
    /* `pts` and `P` has integer value as coordinates
       so `abs(u[2])` < 1 means `u[2]` is 0, that means
       triangle is degenerate, in this case return something with negative coordinates */
    if (std::abs(u.z) < 1)
        return Vec3f(-1, 1, 1);
    return Vec3f(1.f - (u.x + u.y) / u.z, u.y / u.z, u.x / u.z);
}
void triangle(Vec3f *pts, float *zbuffer, PNGImage &image, PNGColor color)
{
    int minX = min({ pts[0].x, pts[1].x, pts[2].x });
    int maxX = max({ pts[0].x, pts[1].x, pts[2].x });
    int minY = min({ pts[0].y, pts[1].y, pts[2].y });
    int maxY = max({ pts[0].y, pts[1].y, pts[2].y });
    int width = image.get_width();
    int height = image.get_height();
    if (maxX >= width)
        maxX = width - 1;
    if (maxY >= height)
        maxY = height - 1;
    Vec3f P;
    for (P.x = minX; P.x <= maxX; P.x++) {
        for (P.y = minY; P.y <= maxY; P.y++) {
            Vec3f bc_screen = barycentric(pts, P);
            if (bc_screen.x < 0 || bc_screen.y < 0 || bc_screen.z < 0) continue;
            P.z = 0;
            for (int i = 0; i < 3; i++)
                P.z += pts[i].z * bc_screen[i];
            if (zbuffer[int(P.x + P.y*width)] < P.z) {
                zbuffer[int(P.x + P.y*width)] = P.z;
                image.set(P.x, P.y, color);
            }
        }
    }
}
Matrix projection(Vec3f eye, Vec3f center)
{
    Matrix m = Matrix::identity(4);
    m[3][2] = -1.f / (eye - center).norm();
    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 lookat(Vec3f eye, Vec3f center, Vec3f up) {
    Vec3f z = (eye - center).normalize();
    Vec3f x = (up^z).normalize();
    Vec3f y = (z^x).normalize();
    Matrix res = Matrix::identity(4);
    for (int i = 0; i < 3; i++) {
        res[0][i] = x[i];
        res[1][i] = y[i];
        res[2][i] = z[i];
        res[i][3] = -center[i];
    }
    return res;
}
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);
    const PNGColor orange = PNGColor(255, 128, 0, 255);
    const PNGColor clr[6] = { green, yellow, blue, red, white, orange };
    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("african_head.obj");
    float *zbuffer = new float[width*height];
    for (int i = 0; i < width * height; i++)
        zbuffer[i] = -numeric_limits<float>::max();
    Vec3f eye(0, 0, 4), center(0, 0, 0), up(0, 1, 0);
    // 请补充代码，添加合适的参数
    /********** Begin ********/
    Vec3f light_dir(0, 0, -1);
    /********** End ********/
    Matrix ModelView = lookat(eye, center, up);
    Matrix Projection = projection(eye, center);
    Matrix ViewPort = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    for (int i = 0; i < model->nfaces(); i++)
    {
        vector<int> face = model->face(i);
        Vec3f world_coords[3], screen_coords[3];
        for (int j = 0; j < 3; j++)
        {
            world_coords[j] = model->vert(face[j]);
            screen_coords[j] = ViewPort * Projection * ModelView * world_coords[j];
        }
        // 每个面的颜色根据该面的法向与入射光的夹角来计算
        /********** Begin ********/
        Vec3f n = (world_coords[2] - world_coords[0]) ^ (world_coords[1] - world_coords[0]);
        n.normalize();
        float intensity = n * light_dir;
        if (intensity < 0.0f)
            intensity = 0.0f;
        PNGColor clr = PNGColor(intensity * 255, intensity * 255, intensity * 255, 255);
        /********** End ********/
        triangle(screen_coords, zbuffer, image, clr);
    }
    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;
    delete zbuffer;
    return 0;
}

第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 barycentric(Vec3f *pts, Vec3f P)
{
    Vec3f u = Vec3f(pts[2].x - pts[0].x, pts[1].x - pts[0].x, pts[0].x - P.x) ^
        Vec3f(pts[2].y - pts[0].y, pts[1].y - pts[0].y, pts[0].y - P.y);
    /* `pts` and `P` has integer value as coordinates
       so `abs(u[2])` < 1 means `u[2]` is 0, that means
       triangle is degenerate, in this case return something with negative coordinates */
    if (std::abs(u.z) < 1)
        return Vec3f(-1, 1, 1);
    return Vec3f(1.f - (u.x + u.y) / u.z, u.y / u.z, u.x / u.z);
}
void triangle(Vec3f *pts, float *zbuffer, PNGImage &image, PNGColor color)
{
    int minX = min({ pts[0].x, pts[1].x, pts[2].x });
    int maxX = max({ pts[0].x, pts[1].x, pts[2].x });
    int minY = min({ pts[0].y, pts[1].y, pts[2].y });
    int maxY = max({ pts[0].y, pts[1].y, pts[2].y });
    int width = image.get_width();
    int height = image.get_height();
    if (maxX >= width)
        maxX = width - 1;
    if (maxY >= height)
        maxY = height - 1;
    Vec3f P;
    for (P.x = minX; P.x <= maxX; P.x++) {
        for (P.y = minY; P.y <= maxY; P.y++) {
            Vec3f bc_screen = barycentric(pts, P);
            if (bc_screen.x < 0 || bc_screen.y < 0 || bc_screen.z < 0) continue;
            P.z = 0;
            for (int i = 0; i < 3; i++)
                P.z += pts[i].z * bc_screen[i];
            if (zbuffer[int(P.x + P.y*width)] < P.z) {
                zbuffer[int(P.x + P.y*width)] = P.z;
                image.set(P.x, P.y, color);
            }
        }
    }
}
void triangle(Vec3f *pts, float *zbuffer, PNGImage &image, Vec3f intensity)
{
    int minX = min({ pts[0].x, pts[1].x, pts[2].x });
    int maxX = max({ pts[0].x, pts[1].x, pts[2].x });
    int minY = min({ pts[0].y, pts[1].y, pts[2].y });
    int maxY = max({ pts[0].y, pts[1].y, pts[2].y });
    int width = image.get_width();
    int height = image.get_height();
    if (maxX >= width)
        maxX = width - 1;
    if (maxY >= height)
        maxY = height - 1;
    Vec3f P;
    for (P.x = minX; P.x <= maxX; P.x++) {
        for (P.y = minY; P.y <= maxY; P.y++) {
            Vec3f bc_screen = barycentric(pts, P);
            if (bc_screen.x < 0 || bc_screen.y < 0 || bc_screen.z < 0) continue;
            P.z = 0;
            for (int i = 0; i < 3; i++)
                P.z += pts[i].z * bc_screen[i];
            if (zbuffer[int(P.x + P.y*width)] < P.z) {
                zbuffer[int(P.x + P.y*width)] = P.z;
                //三角形内部点的光强根据重心坐标与顶点光强插值来计算
                /********** Begin ********/
                float intensity1 = intensity * bc_screen;
                PNGColor clr = PNGColor(255 * intensity1, 255 * intensity1, 255 * intensity1, 255);
                /********** End ********/
                image.set(P.x, P.y, clr);
            }
        }
    }
}
Matrix projection(Vec3f eye, Vec3f center)
{
    Matrix m = Matrix::identity(4);
    m[3][2] = -1.f / (eye - center).norm();
    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 lookat(Vec3f eye, Vec3f center, Vec3f up) {
    Vec3f z = (eye - center).normalize();
    Vec3f x = (up^z).normalize();
    Vec3f y = (z^x).normalize();
    Matrix res = Matrix::identity(4);
    for (int i = 0; i < 3; i++) {
        res[0][i] = x[i];
        res[1][i] = y[i];
        res[2][i] = z[i];
        res[i][3] = -center[i];
    }
    return res;
}
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);
    const PNGColor orange = PNGColor(255, 128, 0, 255);
    const PNGColor clr[6] = { green, yellow, blue, red, white, orange };
    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("african_head.obj");
    float *zbuffer = new float[width*height];
    for (int i = 0; i < width * height; i++)
        zbuffer[i] = -numeric_limits<float>::max();
    Vec3f eye(0, 0, 4), center(0, 0, 0), up(0, 1, 0);
    Vec3f light_dir(0, 0, 1);
    Matrix ModelView = lookat(eye, center, up);
    Matrix Projection = projection(eye, center);
    Matrix ViewPort = viewport(width / 4, width / 4, width / 2, height / 2, depth);
    Matrix VPM = ViewPort * Projection * ModelView;
    for (int i = 0; i < model->nfaces(); i++)
    {
        vector<int> face = model->face(i);
        Vec3f world_coords[3], screen_coords[3], vert_normal[3];
        Vec3f intensity;
        for (int j = 0; j < 3; j++)
        {
            world_coords[j] = model->vert(face[j]);
            screen_coords[j] = VPM * world_coords[j];
            vert_normal[j] = model->normal(i, j);
            //三角形每个顶点的光强根据顶点法线向量与光照方向的点积来计算
            /********** Begin ********/
            intensity[j] = max(0.0f, vert_normal[j] * light_dir);
            /*********** End *********/
        }
        triangle(screen_coords, zbuffer, image, intensity);
    }
    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;
    delete zbuffer;
    return 0;
}

一条僵小鱼
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
CG8-v2.0-光照着色
Junds0的博客
10-21 988
一. 任务描述本关任务 (1) 理解均匀着色算法; (2) 将main函数中的空白部分参数补充完整。输入 (1) 代码将自动输入一个人像模型，具体模型如下图： test (2) 将模型的所有点坐标沿Y轴逆时针方向旋转15度； (3) 进行观察变换，观察点坐标为(0, 0, 4)，中心点坐标为（0，0，0），向上的矢量为(0, 1, 0)； (4) 在triangle函数中输入参数，使模型的每一个三角面片颜色随机生成，其中基础的颜色为PNGColor(255, 255, 255, 255)，随机数用rand(
《计算机图形学》教学上机实验报告
WindsZL的博客
01-11 3942
课程名称： 计算机图形学 实验项目名称： 直线光栅化 实验目的： 1.理解基本图形元素光栅化的基本原理； 2.掌握基本图形元素光栅化方法，如中点方法，Bresenham方法； 3.利用OpenGL实现基本图形元素的光栅化算法。 实验内容与主要代码： 实验内容： 1.根据所给的直线光栅化的示范源程序，在计算机上编译运行，输出正确结果。 2.指出示范程序采用的算法，以此为基础将其改造为中点线算法或Bresenham算法，写入实验报告。 3.根据示范代码，将其改造为圆的光栅化算法，写入实验报告。 4.了解和使用O
计算机图形学头歌实训平台——简单光照效果
weixin_51329675的博客
01-05 1221
计算机图形学头歌实训平台——简单光照效果
第1关 配置颜色条 （educoder
aaaaDea的博客
09-21 5404
Matplotlib 第1关 配置颜色条 （educoder
头歌平台（EduCoder）—— Matplotlib图形配置
热门推荐
dbdxmm的博客
10-12 1万+
为了让我们的图形更加的美化，matplotlib提供了一系列设置图形的方法。 本实训我们将学习这些方法来调整图形。 第1关：配置颜色条 第2关：设置注释 第3关：自定义坐标刻度 第4关：配置文件与样式表 ...
计算机图形学头歌实训平台作业OpenGL简单光照效果
qq_52497285的博客
06-01 2596
简单光照效果第1关 OpenGL球体漫反射第2关 OpenGL球体镜面反射第3关 OpenGL茶壶光照 第1关 OpenGL球体漫反射 // 提示：在合适的地方修改或添加代码 #include <GL/freeglut.h> #include<stdlib.h> // 评测代码所用头文件-开始 #include<opencv2/core/core.hpp> #include<opencv2/highgui/highgui.hpp> #include<op
XJTUSE计算机图形学总结笔记
weixin_47692652的博客
02-16 4746
XJTUSE计算机图形学总结笔记
计算机图形学入门
该剃胡子了的博客
08-08 327
计算机图形学入门，对计算机图形学知识点进行梳理，不断更新中...
计算机图形学光照模型.rar
07-05
光照模型是计算机图形学中的核心概念，它模拟真实世界中光线与物体交互的方式，使得虚拟场景更加生动和真实。在这个“计算机图形学光照模型.rar”压缩包中，我们很显然会探讨光照模型的理论以及可能的应用。 首先，...
计算机图形学基础教程课后习题答案（图片版）
12-17
计算机图形学是信息技术领域的一个重要分支，它主要研究如何在计算机中表示、处理以及显示图形。本教程聚焦于计算机图形学的基础，特别是与Visual C++编程相关的知识，由孔令德编著的《计算机图形学基础教程（Visual...
C++ 孔令德计算机图形学习题答案源代码
03-17
《C++ 孔令德计算机图形学习题答案源代码》是一个专门为学习计算机图形学的学生或爱好者准备的资源，其中包含了孔令德教授课程中的习题解答。这些源代码是使用C++编程语言编写的，因此对于熟悉C++的读者来说，它们...
北交大计算机图形学光照模型大作业.7z
03-16
北交大计算机图形学的完整作业代码，当时花好久才完成，改代码可以说是太难了，并且那个老师还讲不清楚，因此可以看我的代码进行学习，代码修改位置有详细的注释，一共有五次作业，因为整体上传有大小限制，分成了5...
吉林大学计算机图形学答案.zip
08-31
吉林大学提供的这些压缩包文件包含了计算机图形学不同章节的作业答案，可以为我们深入理解计算机图形学的关键概念提供宝贵的参考。 第一部分：计算机图形学基础 计算机图形学的基础包括点、线、面的数学描述，以及...
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 355
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
haproxy算法与具体实现
K1487994142的博客
08-11 981
负载均衡：Load Balance，简称LB，是一种服务或基于硬件设备等实现的高可用反向代理技术，负载均 衡将特定的业务(web服务、网络流量等)分担给指定的一个或多个后端特定的服务器或设备，从而提高了 公司业务的并发处理能力、保证了业务的高可用性、方便了业务后期的水平动态扩展。
【LeetCode】字母异位词分组
最新发布
LittleFishC的博客
08-14 147
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 529
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
【算法模板】计算几何：旋转卡壳求凸包直径
2303_80346267的博客
08-14 371
旋转卡壳算法是一种几何算法，主要用于在二维平面上求解与凸包相关的最优问题。该算法利用凸包顶点的顺序性和对称性，通过模拟两个卡壳（calipers）沿着凸包边界的旋转来寻找最优解。常见的应用包括计算凸包的直径（即最远点对之间的距离）、最小包围矩形（最小面积矩形），以及最小宽度（宽度最小的方向）。
计算机图形学中的衰减因子与光照模型
在计算机图形学中，衰减因子是一个关键概念，尤其是在局部光照明模型中，它用于模拟物体表面的粗糙程度和光照效果。 衰减因子，通常表示为 G，是由微平面理论提出的。微平面理论认为物体表面不是完全平滑的，而是由...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值