【GAMES101】作业6(提高)含BVH与SAH加速查找算法(SVH)和快速排序算法

目录

  • 1. 作业描述
  • 2. 代码中BVH的建立过程
  • 3. 解
    • 3.1 Render
    • 3.2 Intersection
    • 3.3 IntersectP
    • 3.4 getIntersection
  • 4. SAH算法
    • 4.1 算法描述
    • 4.2 代码实现
      • 4.2.1 recursiveSAH
      • 4.2.2 computeSize
      • 4.2.3 注意
  • 5. 快速排序(Quicksort)
  • 6. 效果
  • 7. 附件

1. 作业描述

在之前的编程练习中,我们实现了基础的光线追踪算法,具体而言是光线传输、光线与三角形求交。我们采用了这样的方法寻找光线与场景的交点:遍历场景中的所有物体,判断光线是否与它相交。在场景中的物体数量不大时,该做法可以取得良好的结果,但当物体数量增多、模型变得更加复杂,该做法将会变得非常低效。因此,我们需要加速结构来加速求交过程。在本次练习中,我们重点关注物体划分算法 Bounding Volume Hierarchy (BVH)。本练习要求你实现 Ray-Bounding Volume 求交与 BVH 查找。

首先,你需要从上一次编程练习中引用以下函数:

• Render() in Renderer.cpp: 将你的光线生成过程粘贴到此处,并且按照新框架更新相应调用的格式。
• Triangle::getIntersection in Triangle.hpp: 将你的光线-三角形相交函数粘贴到此处,并且按照新框架更新相应相交信息的格式。

在本次编程练习中,你需要实现以下函数:

• IntersectP(const Ray& ray, const Vector3f& invDir, const std::array& dirIsNeg) in the Bounds3.hpp: 这个函数的 作用是判断包围盒 BoundingBox 与光线是否相交,你需要按照课程介绍的算法实现求交过程。
• getIntersection(BVHBuildNode* node, const Ray ray)in BVH.cpp: 建 立 BVH 之后,我们可以用它加速求交过程。该过程递归进行,你将在其中调用你实现的 Bounds3::IntersectP.

2. 代码中BVH的建立过程

在进行本次作业之前,提前了解代码中BVH的建立过程将会更有助于完成我们的任务,首先看到一开始的入口函数Scene类的buildBVH,这个函数创建了一个BVHAccel类对象,加入所有物体,并把划分方法设置为Naive简单模式,最后保存到场景中

void Scene::buildBVH() {
    printf(" - Generating BVH...\n\n");
    this->bvh = new BVHAccel(objects, 1, BVHAccel::SplitMethod::NAIVE);
}

接下来看到BVHAccel的构建函数,看看它是怎么初始化的,可以看到,它在创建的同时开始了计时,并进入recursiveBuild函数开始了递归构建BVH树的过程

BVHAccel::BVHAccel(std::vector<Object*> p, int maxPrimsInNode,
                   SplitMethod splitMethod)
    : maxPrimsInNode(std::min(255, maxPrimsInNode)), splitMethod(splitMethod),
      primitives(std::move(p))
{
    time_t start, stop;
    time(&start);
    if (primitives.empty())
        return;

    root = recursiveBuild(primitives);

    time(&stop);
    double diff = difftime(stop, start);
    int hrs = (int)diff / 3600;
    int mins = ((int)diff / 60) - (hrs * 60);
    int secs = (int)diff - (hrs * 3600) - (mins * 60);

    printf(
        "\rBVH Generation complete: \nTime Taken: %i hrs, %i mins, %i secs\n\n",
        hrs, mins, secs);
}

在recursiveBuild函数内部,首先是创建一个节点,然后遍历每个物体的getBounds方法获取包围它们的AABB的边界,然后通过Union函数把这些AABB合为一个大的AABB作为节点

BVHBuildNode* BVHAccel::recursiveBuild(std::vector<Object*> objects)
{
    BVHBuildNode* node = new BVHBuildNode();

    // Compute bounds of all primitives in BVH node
    Bounds3 bounds;
    for (int i = 0; i < objects.size(); ++i)
        bounds = Union(bounds, objects[i]->getBounds());
    ...

创建完节点后,我们要根据当前AABB内物体的个数来决定划分的方法,如果只有一个物体,那么它就作为叶节点,并把它的子节点设为空

	...
    if (objects.size() == 1) {
        // Create leaf _BVHBuildNode_
        node->bounds = objects[0]->getBounds();
        node->object = objects[0];
        node->left = nullptr;
        node->right = nullptr;
        return node;
    }
    ...

如果是有两个物体,那么就就将这两个物体分别放入两个子节点中进行遍历,这样就保证了每个节点最多只有一个物体了

    ...
    else if (objects.size() == 2) {
        node->left = recursiveBuild(std::vector{objects[0]});
        node->right = recursiveBuild(std::vector{objects[1]});

        node->bounds = Union(node->left->bounds, node->right->bounds);
        return node;
    }
    ...

如果大于两个物体,那么就要思考如何划分当前的BVH了,这里的做法是遍历物体,通过getBounds()的Centroid()方法找到所有物体的中心,并通过Union函数找到它们覆盖的范围,然后通过maxExtent()方法判断到底是哪个轴覆盖的范围大,返回0,就是x轴范围大,返回1就是y轴大,2就是z轴大

	...
    else {
        Bounds3 centroidBounds;
        int target = objects.size() / 2;
        for (int i = 0; i < objects.size(); ++i)
            centroidBounds =
                Union(centroidBounds, objects[i]->getBounds().Centroid());
        int dim = centroidBounds.maxExtent();
        ...

判断完后,根据不同的情况,将物体根据中心坐标分别按照z、y、z轴排序,

        ...
        switch (dim) {
        case 0:
            std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                return f1->getBounds().Centroid().x <
                       f2->getBounds().Centroid().x;
            });
            break;
        case 1:
            std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                return f1->getBounds().Centroid().y <
                       f2->getBounds().Centroid().y;
            });
            break;
        case 2:
            std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                return f1->getBounds().Centroid().z <
                       f2->getBounds().Centroid().z;
            });
            break;
        }
			...

排序完后将物体对半划分,分别放入两个子节点中进行递归,直到只剩一个物体为止,最后还要将当前节点的AABB赋值为两个子节点的Union,这就是代码中BVH划分的简单方法的全程

			...
        auto beginning = objects.begin();
        auto middling = objects.begin() + (objects.size() / 2);
        auto ending = objects.end();

        auto leftshapes = std::vector<Object*>(beginning, middling);
        auto rightshapes = std::vector<Object*>(middling, ending);

        assert(objects.size() == (leftshapes.size() + rightshapes.size()));

        node->left = recursiveBuild(leftshapes);
        node->right = recursiveBuild(rightshapes);

        node->bounds = Union(node->left->bounds, node->right->bounds);
    }

    return node;
}

3. 解

3.1 Render

首先是render函数和getIntersection函数的填写,基本只用把上次作业的代码复制过来就行了,需要注意的一点是,castRay函数被转移到了Scene类里面,还要把之前计算的光线通过定义ray类对象传入函数

void Renderer::Render(const Scene& scene)
{
    std::vector<Vector3f> framebuffer(scene.width * scene.height);

    float scale = tan(deg2rad(scene.fov * 0.5));
    float imageAspectRatio = scene.width / (float)scene.height;
    Vector3f eye_pos(-1, 5, 10);
    int m = 0;
    for (uint32_t j = 0; j < scene.height; ++j) {
        for (uint32_t i = 0; i < scene.width; ++i) {
            // generate primary ray direction
            float x = (2 * (i + 0.5) / (float)scene.width - 1) *
                      imageAspectRatio * scale;
            float y = (1 - 2 * (j + 0.5) / (float)scene.height) * scale;
            Vector3f dir = Vector3f(x, y, -1); // Don't forget to normalize this direction!
            dir = normalize(dir);
            Ray ray(eye_pos, dir, 0);
            framebuffer[m++] = scene.castRay(ray, 0);
        	...

3.2 Intersection

在Intersection函数里面计算了三角形与光线的交点,其实基本计算过程都给出了,我们要做的就是把计算结果放入Intersection类对象,这个类包含了以下几种属性:

①happened:true为相交
②obj:相交的物体
③normal:相交点的法向量
④coords:相交点坐标
⑤m:相交点表面材质

只要注意把这些属性赋值正确就行

inline Intersection Triangle::getIntersection(Ray ray)
{
    Intersection inter;

    if (dotProduct(ray.direction, normal) > 0)
        return inter;
    double u, v, t_tmp = 0;
    Vector3f pvec = crossProduct(ray.direction, e2);
    double det = dotProduct(e1, pvec);
    if (fabs(det) < EPSILON)
        return inter;

    double det_inv = 1. / det;
    Vector3f tvec = ray.origin - v0;
    u = dotProduct(tvec, pvec) * det_inv;
    if (u < 0 || u > 1)
        return inter;
    Vector3f qvec = crossProduct(tvec, e1);
    v = dotProduct(ray.direction, qvec) * det_inv;
    if (v < 0 || u + v > 1)
        return inter;
    t_tmp = dotProduct(e2, qvec) * det_inv;

    // TODO find ray triangle intersection
    inter.happened = true;
    inter.obj = this;
    inter.distance = t_tmp;
    inter.normal = normal;
    inter.coords = ray(t_tmp);
    inter.m = this->m;

    return inter;
}

3.3 IntersectP

这个函数的作用是判断光线与AABB是否有交点,方便后续判断(如果没有交点,自然就不用继续对其子节点进行继续判断了)

这里我用到是课上推导的判断条件:
【GAMES101】作业6(提高)含BVH与SAH加速查找算法(SVH)和快速排序算法_第1张图片

  • texit为负,说明AABB在光线的后面,不相交
  • tenter<0且texit>=0,说明光线在AABB内,一定相交
  • 若算得的tenter

需要注意的是,一开始是用的默认光线方向为正的方法计算,所以如果光线方向为负的话算得的tmin和tmax就反了,这里需要通过判断光线方向的正负来纠正算得的tmin和tmax

inline bool Bounds3::IntersectP(const Ray& ray, const Vector3f& invDir) const
{
    // invDir: ray direction(x,y,z), invDir=(1.0/x,1.0/y,1.0/z), use this because Multiply is faster that Division
    // dirIsNeg: ray direction(x,y,z), dirIsNeg=[int(x>0),int(y>0),int(z>0)], use this to simplify your logic
    // TODO test if ray bound intersects
    Vector3f tmin = (pMin - ray.origin) * invDir;
    Vector3f tmax = (pMax - ray.origin) * invDir;
    Vector3f dir = ray.direction;
    if(dir.x < 0)
        std::swap(tmin.x, tmax.x);
    if(dir.y < 0)
        std::swap(tmin.y, tmax.y);
    if(dir.z < 0)
        std::swap(tmin.z, tmax.z);
    float ten, tex;
    tex = fmin(tmax.x, fmin(tmax.y, tmax.z));
    ten = fmax(tmin.x, fmax(tmin.y, tmin.z));
    if(ten < tex && tex > 0)
        return true;
    return false;
}

3.4 getIntersection

这个函数的作用是获取光线与BVH的交点,而且根据作业的提示,是递归求交,所以这里我的实现思路是:若光线与这个AABB没有交点就直接返回,否则只有当前节点没有子节点了再进行求交,如果有子节点就继续对两个子节点进行递归

Intersection BVHAccel::getIntersection(BVHBuildNode* node, const Ray& ray) const
{
    // TODO Traverse the BVH to find intersection
    Intersection intersect, intersectl, intersectr;
    if(!node->bounds.IntersectP(ray, ray.direction_inv))
        return intersect;
    if(node->left == nullptr && node->right == nullptr){
        intersect = node->object->getIntersection(ray);
        return intersect;
    }
    intersectl = getIntersection(node->left,ray);
    intersectr = getIntersection(node->right,ray);
    return intersectl.distance < intersectr.distance ? intersectl : intersectr;
}

4. SAH算法

4.1 算法描述

作业给的SAH参考资料过于简略,所以这部分的内容还参考了:SAH算法

在建立BVH树的时候,框架代码里面的方法逻辑是比较粗暴的。

简单来说就是判断节点的包围盒在哪个轴上覆盖的范围大,然后根据对应轴坐标对所有物体排个序,然后取中间点作为分界,有点简单粗暴。下面我们介绍一种比较好的划分办法-SAH算法

直观的来说 SAH算法奖励三角形多的小节点,避免三角形少的大节点。看下图我们直观的就可以看出第三种划分方式是最好的。
SAH算法对于不同的划分办法会计算其cost,选取最优的那一种来划分

度量办法:
在这里插入图片描述

  • C(A, B) 光线与这个节点相交的成本
  • t_traversal 是光线与中间节点相交的成本
  • p_A and p_B 是光线通过包围盒A与包围盒B的概率(这个概率指A或B包围盒的表面积/整个包围盒的表面积,这也就是SAH,Surface area Heuristic名称的由来)
  • N_A and N_B 是包围盒A和包围盒B中物体数量
  • t_intersect 是对一个物体的光线相交计算成本

假设costs t_traversal = 1 and t_intersect = 2

对于我们之前提到的那个例子 我们可以定量的计算这三种划分方式的开销 如下图
【GAMES101】作业6(提高)含BVH与SAH加速查找算法(SVH)和快速排序算法_第2张图片

4.2 代码实现

4.2.1 recursiveSAH

首先,SAH对于物体数量为1和2的节点的处理方法基本与基础BVH划分方法相同,只有一个物体了就设置当前为叶节点,只有两个时就把两个物体分别给到两个子节点进行递归处理

BVHBuildNode* BVHAccel::recursiveSAH(std::vector<Object*> objects){
    BVHBuildNode* node = new BVHBuildNode();

    // Compute bounds of all primitives in BVH node
    Bounds3 bounds;
    for (int i = 0; i < objects.size(); ++i)
        bounds = Union(bounds, objects[i]->getBounds());
    if (objects.size() == 1) {
        // Create leaf _BVHBuildNode_
        node->bounds = objects[0]->getBounds();
        node->object = objects[0];
        node->left = nullptr;
        node->right = nullptr;
        return node;
    }
    else if (objects.size() == 2) {
        node->left = recursiveSAH(std::vector{objects[0]});
        node->right = recursiveSAH(std::vector{objects[1]});
        node->bounds = Union(node->left->bounds, node->right->bounds);
        return node;
    }
    ...

对于两个以上物体的节点,还需要分两种情况讨论,这里认为物体数量小于12时,对半分的效率要大于用SAH查找划分的效率

    ...
    else {
        auto beginning = objects.begin();
        auto ending = objects.end();
        if(objects.size() < 12){
            auto middling = objects.begin() +objects.size() / 2;
            auto leftshapes = std::vector<Object*>(beginning, middling);
            auto rightshapes = std::vector<Object*>(middling, ending);
            node->left = recursiveSAH(leftshapes);
            node->right = recursiveSAH(rightshapes);
            node->bounds = Union(node->left->bounds, node->right->bounds);
        }
        ...

如果物体数量大于12时,则正式开始SAH算法,首先分三种dim情况讨论,就是分别基于x、y、z轴来划分

        ...
        else {
            int bestChoice = 0;
            double minCost = std::numeric_limits<double >::max();
            int bestDim = 0;
            for(int dim = 0; dim < 3; dim++){
                switch (dim) {
                    case 0:
                        std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                            return f1->getBounds().Centroid().x <
                                   f2->getBounds().Centroid().x;
                        });
                        break;
                    case 1:
                        std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                            return f1->getBounds().Centroid().y <
                                   f2->getBounds().Centroid().y;
                        });
                        break;
                    case 2:
                        std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                            return f1->getBounds().Centroid().z <
                                   f2->getBounds().Centroid().z;
                        });
                        break;
                }
                ...

确定了划分轴以后该怎么确定分界线最好呢?这里遍历了5种选择,分别是在包围盒1/6到5/6处进行划分

                ...
                auto l = (float)objects.size();
                float nums[] = {1.0/6, 2.0/6, 3.0/6, 4.0/6, 5.0/6};
                for(int i = 0; i < 5; i++)
                    nums[i] *= l;
                ...

确定了分界线后,就按照之前提到的SAH公式来进行花费的计算
在这里插入图片描述

				...
                for(int i = 0; i < 5; i++){
                    auto middling = objects.begin() + (int)nums[i];
                    auto leftshapes = std::vector<Object*>(beginning, middling);
                    auto rightshapes = std::vector<Object*>(middling, ending);
                    double leftBoxSize = computeSize(leftshapes);
                    double rightBoxSize = computeSize(rightshapes);
                    double cost = 2.f + (leftBoxSize * leftshapes.size() + rightBoxSize * rightshapes.size()) / bounds.SurfaceArea();
                    ...

算完花费以后判断是否是当前最小的花费,是的话就记录分界线bestChoice和划分轴bestDim

                    ...
                    if(cost < minCost){   
                        bestChoice = (int)nums[i];
                        bestDim = dim;
                    }
                }
            }
            ...

这样,在遍历完所有情况以后整理结果,根据最后的bestDim将物体按照对应的轴排序(不再对z轴排序是因为遍历结束时就是按照z轴排序的),然后按照分界线将左右两组物体放进两个子节点中进行递归,这就是SAH的全部流程

            ...
            if(bestDim == 0)
                std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                    return f1->getBounds().Centroid().x <
                        f2->getBounds().Centroid().x;
                });
            if(bestDim == 1)
                std::sort(objects.begin(), objects.end(), [](auto f1, auto f2) {
                    return f1->getBounds().Centroid().y <
                        f2->getBounds().Centroid().y;
                });
            auto middling = objects.begin() + bestChoice;
            auto leftshapes = std::vector<Object*>(beginning, middling);
            auto rightshapes = std::vector<Object*>(middling, ending);
            node->left = recursiveSAH(leftshapes);
            node->right = recursiveSAH(rightshapes);
            node->bounds = Union(node->left->bounds, node->right->bounds);
        }
        return node;
    }
}

4.2.2 computeSize

在SAH的公式中提到的自定义computeSize函数就是求被物体组成的包围盒的面积

double BVHAccel::computeSize(std::vector<Object*> objects){
    Bounds3 centroidBounds;
    for (int i = 0; i < objects.size(); ++i)
        centroidBounds =
            Union(centroidBounds, objects[i]->getBounds());
    return centroidBounds.SurfaceArea();
}

4.2.3 注意

别忘了在BVHAccel构建函数的入口处添加对加速方法的判断

	if(splitMethod == BVHAccel::SplitMethod::NAIVE)
        root = recursiveBuild(primitives);
    else
        root = recursiveSAH(primitives);

5. 快速排序(Quicksort)

(ps:该部分只是对老师上课提到的内容的补充,不作要求,感兴趣的朋友可以了解一下)

快速排序是对冒泡算法的一种改进:
任意选取一个数据(通常选用数组的第一个数)作为关键数据,然后将所有比它小的数都放到它左边,所有比它大的数都放到它右边,这个过程称为一趟快速排序。

假设一开始序列{xi}是:5,3,7,6,4,1,0,2,9,10,8。
此时,ref=5,i=1,j=10,从后往前找,第一个比5小的数是x8=2。
此时i=1,j=8,从前往后找,第一个比5大的数是x3=7,因此序列为:5,3,2,6,4,1,0,7,9,10,8。
此时,i=3,j=8,从第8位往前找,第一个比5小的数是x7=0。
此时,i=3,j=7,从第3位往后找,第一个比5大的数是x4=6,因此:5,3,2,0,4,1,6,7,9,10,8。
此时,i=4,j=7,从第7位往前找,第一个比5小的数是x6=1。
此时,i=4,j=6,从第4位往后找,直到第6位才有比5大的数,这时,i=j=6,ref成为一条分界线,它之前的数都比它小,之后的数都比它大,因此最后:1,3,2,0,4,5,6,7,9,10,8
对于前后两部分数,可以采用同样的方法来排序

这里给出一个按z轴排序的例子:

void BVHAccel::quicksort_z(int first, int last, int target, std::vector<Object*> &objects){
    int i = first + 1, j = last;
    while (true) {
		while (j > first && objects[j]->getBounds().Centroid().z >= objects[first]->getBounds().Centroid().z)
			j--;
		while (i < last && objects[i]->getBounds().Centroid().z <= objects[first]->getBounds().Centroid().z)
			i++;
		if (i >= j) 
			break;
		std::swap(objects[i],objects[j]);
	}
	std::swap(objects[j], objects[first]);
    if(j > target)
        quicksort_x(first, j - 1, target, objects);
    if(j < target)
        quicksort_x(j + 1, last, target, objects);
}
BVHBuildNode* BVHAccel::recursiveBuild(std::vector<Object*> objects)
{
    BVHBuildNode* node = new BVHBuildNode();

    // Compute bounds of all primitives in BVH node
    Bounds3 bounds;
    for (int i = 0; i < objects.size(); ++i)
        bounds = Union(bounds, objects[i]->getBounds());
    if (objects.size() == 1) {
        // Create leaf _BVHBuildNode_
        node->bounds = objects[0]->getBounds();
        node->object = objects[0];
        node->left = nullptr;
        node->right = nullptr;
        return node;
    }
    else if (objects.size() == 2) {
        node->left = recursiveBuild(std::vector{objects[0]});
        node->right = recursiveBuild(std::vector{objects[1]});

        node->bounds = Union(node->left->bounds, node->right->bounds);
        return node;
    }
    else {
        Bounds3 centroidBounds;
        int target = objects.size() / 2;
        for (int i = 0; i < objects.size(); ++i)
            centroidBounds =
                Union(centroidBounds, objects[i]->getBounds().Centroid());
        int dim = centroidBounds.maxExtent();
        switch (dim) {
        case 0:
            quicksort_x(0, objects.size(), objects.size() / 2, objects);
            break;
        case 1:
            quicksort_y(0, objects.size(), objects.size() / 2, objects);
            break;
        case 2:
            quicksort_z(0, objects.size(), objects.size() / 2, objects);
            break;
        }
		...

6. 效果

基本与实例一致
【GAMES101】作业6(提高)含BVH与SAH加速查找算法(SVH)和快速排序算法_第3张图片

NAIVE耗时:
【GAMES101】作业6(提高)含BVH与SAH加速查找算法(SVH)和快速排序算法_第4张图片

SVH耗时:
【GAMES101】作业6(提高)含BVH与SAH加速查找算法(SVH)和快速排序算法_第5张图片

可见,SVH还是对BVH的加速作用有效果的,可能在物体分布的更不均匀的情况下效果能更好。

7. 附件

附上源代码,有兴趣的朋友可以自己尝试一下效果:
CSDN:【GAMES101】作业6
GITHUB:【GAMES101】作业合集

你可能感兴趣的:(GAMES101-计算机图形学,c++,线性代数,图形渲染,排序算法)