GAMES101-Homework2

最新推荐文章于 2025-03-19 11:40:16 发布
最新推荐文章于 2025-03-19 11:40:16 发布
阅读量448 收藏 7
点赞数 10
分类专栏： 计算机图形学 文章标签： GAMES01
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/mumuhaoshuai/article/details/134586043
版权

目录

普通作业：

// 判断点是否在三角形内的辅助函数
static bool insideTriangle(float x, float y, const Vector3f* _v)
{
    //Vector3f* _v这个参数是一个Vector3f指针，实际上代表的是一个数组。数组中的每个元素是一个Vector3f类型，
   //也就是代表了一个顶点的坐标。每个点用_v[0]，_v[1]，_v[2]表示。而每个_v[0]就是一个Vector3f类型的点。
   // //整个数组代表了多个点。这里一般认为传入的是三个点，即一个三角形。
    const Eigen::Vector2f P(x, y);

    // 提取x和y
    const Eigen::Vector2f A = _v[0].head(2), B = _v[1].head(2), C = _v[2].head(2);
    // 计算需求的向量
    const Eigen::Vector2f AP = P - A;
    const Eigen::Vector2f BP = P - B;
    const Eigen::Vector2f CP = P - C;
    const Eigen::Vector2f AB = B - A;
    const Eigen::Vector2f BC = C - B;
    const Eigen::Vector2f CA = A - C;

    //计算叉积
    float eq1 = AB[0] * AP[1] - AB[1] * AP[0];
    float eq2 = BC[0] * BP[1] - BC[1] * BP[0];
    float eq3 = CA[0] * CP[1] - CA[1] * CP[0];

    //判断是否同向
    if (eq1 > 0 && eq2 > 0 && eq3 > 0)
        return true;
    else if (eq1 < 0 && eq2 < 0 && eq3 < 0)
        return true;
    else
        return false;


    // TODO: 实现此函数，检查点 (x, y) 是否在由 _v[0]、_v[1]、_v[2] 表示的三角形内
}


// 屏幕空间光栅化
void rst::rasterizer::rasterize_triangle(const Triangle& t)
{
    auto v = t.toVector4();
    int min_x = INT_MAX;
    int max_x = INT_MIN;
    int min_y = INT_MAX;
    int max_y = INT_MIN;
    //找出包围盒的边界
    for (auto point : v)
    {
        if (point[0] < min_x) min_x = point[0];
        if (point[0] > max_x) max_x = point[0];
        if (point[1] < min_y) min_y = point[1];
        if (point[1] > max_y) max_y = point[1];
    }

    for (int y = min_y; y <= max_y; y++)
    {
        for (int x = min_x; x <= max_x; x++)
        {
            if (insideTriangle((float)x + 0.5, (float)y + 0.5, t.v))
            {
                // 如果是这样，使用以下代码获取插值的 z 值。
               // auto [alpha, beta, gamma] = computeBarycentric2D(x, y, t.v);   C++17以上的版本才可以用此句，否则修改成下面的俩句
                float alpha, beta, gamma;
                std::tie(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;

                if (z_interpolated < depth_buf[get_index(x, y)])
                {
                    Eigen::Vector3f p = { (float)x,(float)y, z_interpolated }; //当前坐标
                    set_pixel(p, t.getColor());
                    depth_buf[get_index(x, y)] = z_interpolated; //更新z值
                }
            
            }
        }
    }

    // TODO: 找出当前三角形的边界框。
    // 遍历像素并查找当前像素是否在三角形内

    // 如果是这样，使用以下代码获取插值的 z 值。
    // 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_pixel 函数）为三角形的颜色（使用 getColor 函数），如果应该绘制的话。
}

提高作业：

MSAA多重采样抗锯齿
这个算法很简单，只要把判断像素中心点在不在三角形内改成判断像素块中的四个采样点在不在三角形内，然后按点在三角形内的比例去改变颜色就行，话不多说看代码更清楚：

void rst::rasterizer::rasterize_triangle(const Triangle& t) {
    auto v = t.toVector4();
    int min_x = INT_MAX;
    int max_x = INT_MIN;
    int min_y = INT_MAX;
    int max_y = INT_MIN;
    for (auto point : v)
    {
        if (point[0] < min_x) min_x = point[0];
        if (point[0] > max_x) max_x = point[0];
        if (point[1] < min_y) min_y = point[1];
        if (point[1] > max_y) max_y = point[1];
    }
    
    //MSAA:
    for (int y = min_y; y <= max_y; y++)
    {
        for (int x = min_x; x <= max_x; x++)
        {
            float fineness = 0; //创建一个纯度值
            if (insideTriangle((float)x + 0.25, (float)y + 0.25, t.v)) fineness += 0.25; //改为判断四个采样块的中心点在不在三角形内
            if (insideTriangle((float)x + 0.25, (float)y + 0.75, t.v)) fineness += 0.25;
            if (insideTriangle((float)x + 0.75, (float)y + 0.25, t.v)) fineness += 0.25;
            if (insideTriangle((float)x + 0.75, (float)y + 0.75, t.v)) fineness += 0.25;
            if (fineness != 0) 
            {
                auto abg = computeBarycentric2D((float)x + 0.5, (float)y + 0.5, t.v);
                float alpha = std::get<0>(abg);
                float beta = std::get<1>(abg);
                float gamma = std::get<2>(abg);
                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 (z_interpolated < depth_buf[get_index(x, y)])
                {
                    Eigen::Vector3f p = { (float)x,(float)y, z_interpolated };
                    set_pixel(p, fineness*t.getColor()); //将比例乘给颜色
                    depth_buf[get_index(x, y)] = z_interpolated;
                }
            }
        }
    }
}

参考博客

博客一

博客二

博客三

附代码框架的个人一些注释和理解：

rasterizer.cpp

// 防止代码格式化
//
// 由 goksu 于 4/6/19 创建

#include <algorithm>
#include <vector>
#include "rasterizer.h"
#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)
{
    //Vector3f* _v这个参数是一个Vector3f指针，实际上代表的是一个数组。数组中的每个元素是一个Vector3f类型，
   //也就是代表了一个顶点的坐标。每个点用_v[0]，_v[1]，_v[2]表示。而每个_v[0]就是一个Vector3f类型的点。
   // //整个数组代表了多个点。这里一般认为传入的是三个点，即一个三角形。
    const Eigen::Vector2f P(x, y);

    // 提取x和y
    const Eigen::Vector2f A = _v[0].head(2), B = _v[1].head(2), C = _v[2].head(2);
    // 计算需求的向量
    const Eigen::Vector2f AP = P - A;
    const Eigen::Vector2f BP = P - B;
    const Eigen::Vector2f CP = P - C;
    const Eigen::Vector2f AB = B - A;
    const Eigen::Vector2f BC = C - B;
    const Eigen::Vector2f CA = A - C;

    //计算叉积
    float eq1 = AB[0] * AP[1] - AB[1] * AP[0];
    float eq2 = BC[0] * BP[1] - BC[1] * BP[0];
    float eq3 = CA[0] * CP[1] - CA[1] * CP[0];

    //判断是否同向
    if (eq1 > 0 && eq2 > 0 && eq3 > 0)
        return true;
    else if (eq1 < 0 && eq2 < 0 && eq3 < 0)
        return true;
    else
        return false;


    // TODO: 实现此函数，检查点 (x, y) 是否在由 _v[0]、_v[1]、_v[2] 表示的三角形内
}

// 计算二维重心坐标的辅助函数
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)
        };
        // 齐次除法
        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>());
        }

        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);
    }
}

//------------------补充——————————————————————————
// 屏幕空间光栅化
void rst::rasterizer::rasterize_triangle(const Triangle& t)
{
    auto v = t.toVector4();
    int min_x = INT_MAX;
    int max_x = INT_MIN;
    int min_y = INT_MAX;
    int max_y = INT_MIN;
    //找出包围盒的边界
    for (auto point : v)
    {
        if (point[0] < min_x) min_x = point[0];
        if (point[0] > max_x) max_x = point[0];
        if (point[1] < min_y) min_y = point[1];
        if (point[1] > max_y) max_y = point[1];
    }

    for (int y = min_y; y <= max_y; y++)
    {
        for (int x = min_x; x <= max_x; x++)
        {
            if (insideTriangle((float)x + 0.5, (float)y + 0.5, t.v))
            {
                // 如果是这样，使用以下代码获取插值的 z 值。
               // auto [alpha, beta, gamma] = computeBarycentric2D(x, y, t.v);   C++17以上的版本才可以用此句，否则修改成下面的俩句
                float alpha, beta, gamma;
                std::tie(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;

                if (z_interpolated < depth_buf[get_index(x, y)])
                {
                    Eigen::Vector3f p = { (float)x,(float)y, z_interpolated }; //当前坐标
                    set_pixel(p, t.getColor());
                    depth_buf[get_index(x, y)] = z_interpolated; //更新z值
                }
            
            }
        }
    }

    // TODO: 找出当前三角形的边界框。
    // 遍历像素并查找当前像素是否在三角形内

    // 如果是这样，使用以下代码获取插值的 z 值。
    // 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_pixel 函数）为三角形的颜色（使用 getColor 函数），如果应该绘制的话。
}

// 设置模型矩阵的函数
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)
{
    // 旧的索引：auto ind = point.y() + point.x() * width;
    auto ind = (height - 1 - point.y()) * width + point.x();
    frame_buf[ind] = color;
}

Triangle.cpp

//
// Created by LEI XU on 4/11/19.
//

#include "Triangle.h"
#include <algorithm>
#include <array>

// 初始化三角形的顶点坐标、颜色和纹理坐标为零向量或零值
Triangle::Triangle() {
    v[0] << 0, 0, 0;
    v[1] << 0, 0, 0;
    v[2] << 0, 0, 0;

    color[0] << 0.0, 0.0, 0.0;
    color[1] << 0.0, 0.0, 0.0;
    color[2] << 0.0, 0.0, 0.0;

    tex_coords[0] << 0.0, 0.0;
    tex_coords[1] << 0.0, 0.0;
    tex_coords[2] << 0.0, 0.0;
}
// 设置三角形的顶点坐标
void Triangle::setVertex(int ind, Vector3f ver) {
    v[ind] = ver;
}
// 设置三角形的法向量
void Triangle::setNormal(int ind, Vector3f n) {
    normal[ind] = n;
}
// 设置三角形的颜色
void Triangle::setColor(int ind, float r, float g, float b) {
    if ((r < 0.0) || (r > 255.) ||
        (g < 0.0) || (g > 255.) ||
        (b < 0.0) || (b > 255.)) {
        fprintf(stderr, "ERROR! Invalid color values");
        fflush(stderr);
        exit(-1);
    }
    // 将颜色值存储为范围在[0, 1]之间的Vector3f
    color[ind] = Vector3f((float)r / 255., (float)g / 255., (float)b / 255.);
    return;
}
// 设置三角形的纹理坐标
void Triangle::setTexCoord(int ind, float s, float t) {
    tex_coords[ind] = Vector2f(s, t);
}
// 将三角形的顶点坐标转换为四维向量
//这里transform()是stl算法，作用是将第一个迭代器的元素做op变换之后放到第二个迭代器中，
//最后一个位置的参数代表重载() {}运算符的操作。这里的transform的意思就是将v中vec的xyz存给res
std::array<Vector4f, 3> Triangle::toVector4() const
{
    std::array<Eigen::Vector4f, 3> res;
    std::transform(std::begin(v), std::end(v), res.begin(), [](auto& vec) { return Eigen::Vector4f(vec.x(), vec.y(), vec.z(), 1.f); });
    return res;
}
GAMES202-homework-2
02-14
《GAMES202-homework-2：深入理解预计算辐射传输（PRT）》 在游戏开发和计算机图形学领域，Precomputed Radiance Transfer（PRT，预计算辐射传输）是一种先进的光照处理技术，它能够显著提高游戏场景的视觉质量和...
GAMES202-homework-0
02-14
【标题】"GAMES202-homework-0"是一个关于WebGL框架应用和Blinn-Phong着色模型的学习任务，旨在让学生掌握在Web环境下进行3D图形渲染的基本技能。 【描述】"GAMES202作业0"的重点在于WebGL，这是一种JavaScript API...
GAMES101-Homework0&Homework1
个人学习的一些笔记
11-15 115
【代码】Games101-Homework。
GAMES101-Homework4
个人学习的一些笔记
12-18 441
【代码】GAMES101-Homework4。
网课:GAMES101-homework pa0
dlvector的博客
04-12 400
作业１还是挺简单的，把课上一些基本的概念写成代码即可。 #include<cmath> #include<eigen3/Eigen/Core> #include<eigen3/Eigen/Dense> #include<iostream> int main(){ // Basic Example of cpp std::cout << "Example of cpp \n"; float a = 1.0, b = 2.
GAMES101-现代计算机图形学入门（Assignment0）
lzh804121985的博客
03-19 327
GAMES101的作业1：点旋转和平移矩阵的齐次坐标表示
GAMES101-作业5
weixin_45455414的博客
05-28 2501
Render部分，这里的公式其实是经历了三次变换：光栅化空间，正交空间，屏幕空间，具体原理参照这篇博客的翻译，讲的很清楚 for (int j = 0; j < scene.height; ++j) { for (int i = 0; i < scene.width; ++i) { // generate primary ray directionS float x=(2*(float(i)+0.5)
GAMES101-计算机图形学-作业7
qq_40297109的博客
05-16 360
2 调通框架 2.1 修改的内容 相比上一次实验，本次实验对框架的修改较大，主要在以下几方面： • 修改了main.cpp，以适应本次实验的测试模型CornellBox • 修改了Render，以适应CornellBox 并且支持Path Tracing 需要的同一Pixel多次Sample • 修改了Object，Sphere，Triangle，TriangleMesh，BVH，添加了area 属性与Sample 方法，以实现对光源按面积采样，并在Scene 中添加了采样光源的接口sampleLight
Games101Homework【2】Triangles and Z-buffering
weixin_61943345的博客
03-23 781
Games101Homework【2】Triangles and Z-buffering
网课:GAMES101-homewor1
dlvector的博客
07-25 307
本次作业主要是补充两个函数，实现的目标是一个三角形绕着一个轴旋转．主要是使用课上ＰＰＴ４里面涉及的内容． 主要讲解了三个矩阵，ＭＶＰ． 对应在计算机里的拍照，实际上是这三步： Model：把要成像的物体摆好位置。 View：摆好照相机的位置，对准。 Projection：成像！ 它们分别对应着三种变换，这就是 MVP transformation，我们目前要做的，就是搞清楚它们是怎么变换的。 第一个模型的变化矩阵的旋转矩阵是最简单的，直接从２维度的情况推演过来就可以了． Eigen::Matrix4f g
Games101Homework【6】Code Part
weixin_61943345的博客
04-01 537
【代码】Games101Homework【6】Code Part
GAMES202-homework-5
02-14
【标题】"GAMES202-homework-5"涉及的是一个与计算机图形学相关的课程作业，专注于实时光线追踪降噪技术（Real-Time Ray Tracing with Denoising，简称RTRT）。这个作业是GAMES202课程的一部分，可能在探讨如何在...
GAMES202-homework-1
02-14
"GAMES202-homework-1"是一个针对GAMES202课程的作业，其主题是“实时阴影”。实时阴影在游戏开发中扮演着至关重要的角色，因为它能够极大地提升游戏的视觉真实感和沉浸感。在本作业中，学生将被要求深入理解并实现...
GAMES202-homework-3
02-14
2. **发射屏幕空间光线**：从每个像素的中心向屏幕外发射一条虚拟光线，这条光线的方向通常与像素的法线有关。 3. **反射和折射**：当光线遇到表面时，根据表面的材质属性（如镜面反射、漫反射或透明），计算出反射...
第五讲电子商务安全.ppt
05-26
第五讲电子商务安全.ppt
运用Matlab的LBP算法实现面部表情识别与特征分割 图像处理 指南
05-26
内容概要：本文探讨了利用Matlab和LBP（局部二值模式）算法进行面部表情识别的技术。首先介绍了Matlab作为一种强大工具，在科学计算和图像处理领域的广泛应用背景。接着详细阐述了LBP算法的工作原理及其在图像分析中的优势，特别是对于描述图像局部纹理特征的能力。随后重点讲解了LBP算法在脸部特征分割中的具体步骤，包括图像预处理、特征提取以及最终的表情识别过程。通过对一系列实验数据的分析，证明了这种方法的有效性和准确性。 适合人群：从事计算机视觉、图像处理相关工作的研究人员和技术爱好者。 使用场景及目标：适用于需要对面部表情进行自动识别的应用场合，如安防监控、人机交互系统等。目标在于提供一种高效可靠的面部表情识别解决方案。 其他说明：文中提到的LBP算法不仅能够很好地捕捉到人脸的关键部位特征，而且还能有效地减少噪声干扰，提高了识别率。此外，作者还展望了未来可能的研究方向，比如优化现有算法以提升性能表现。
MATLAB微网优化调度：两阶段鲁棒CCG算法经济调度的详细研究 说明
最新发布
05-26
内容概要：本文深入探讨了基于MATLAB的微网优化调度，特别是采用两阶段鲁棒优化模型和CCG算法来实现经济调度。通过构建min-max-min结构的两阶段鲁棒优化模型，考虑储能、需求侧负荷及可控分布式电源的运行约束和协调控制，并引入不确定性调节参数，使调度方案能够适应不同场景。利用列约束生成算法和强对偶理论，将原问题分解为主问题和子问题交替求解，提高了求解效率。最终，在MATLAB平台上利用YALMIP工具箱调用CPLEX求解器进行了仿真分析，验证了模型和算法的有效性。 适合人群：从事电力系统优化调度的研究人员和技术人员，尤其是对微网优化调度感兴趣的学者和工程师。 使用场景及目标：适用于需要优化微网调度策略，降低成本并提高能源利用效率的实际应用场景。目标是在最恶劣场景下找到运行成本最低的调度方案，同时确保系统的稳定性。 其他说明：本文提供的代码注释详实，出图效果好，适合用于教学和科研项目。
工业自动化中昆仑通态触摸屏控制ABB变频器的技术实现与应用
05-26
内容概要：本文详细介绍了昆仑通态触摸屏控制ABB变频器的技术实现过程及其应用场景。首先简述了昆仑通态触摸屏技术和ABB变频器的基本概念，接着重点讲解了两者之间的硬件连接和软件编程方法，包括具体的代码示例。文中还探讨了该技术在多个行业的广泛应用及其带来的诸多优势，如操作简便、节能高效等。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是对触摸屏控制技术和变频器有研究兴趣的人士。 使用场景及目标：适用于机械制造、化工、纺织、食品加工等多个行业，旨在提升生产线的自动化水平，优化设备操作流程，达到节能增效的目的。 其他说明：随着工业自动化的快速发展，此类技术将在更多领域得到推广和应用。文中提供的代码片段有助于读者快速上手实践，加深对该技术的理解。
“终极版本的asdf文件压缩包”
05-26
假设使用一个带权有向图来表示某地区的公交线路网络，图中的顶点对应区域内的重要站点，有向边代表已开通的公交线路，边上的权重则表示乘坐该线路的票价或所需时间。在此基础上，设计一款交通指南系统，为使用者提供从该区域内的一个站点出发，以最低票价或最短时间到达另一个站点的最优路径指导。
GAMES202作业2：探究预计算辐射传输技术
资源摘要信息:"GAMES202-homework-2" 在本篇文章中，我们将深入探讨和分析“GAMES202-homework-2”这一资源，它涉及到一个在计算机图形学领域中非常重要的技术——预计算辐射传输（Precomputed Radiance Transfer，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值