Instance(案例)

最新推荐文章于 2024-10-14 22:26:18 发布
最新推荐文章于 2024-10-14 22:26:18 发布
阅读量904 收藏 13
点赞数 9
文章标签： windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57958061/article/details/141220312
版权

Cornell Box一般来说还有两个box，这里我们可以撞见六边面来模拟

对于一个立方体，六个面，分别的求每个面的形状就可以。其步骤如下：

  1. 假定立方体就是正对的（轴与x,y,z轴平行）
  2. 利用立方体的每个轴的最小值和最大值来定义边界。
  3. 最后得到这个立方体的每个面，每个面都是一个quad，所以可以定义一个hittable_list去记录所有的quad

定义边界点

auto min = Point3(std::fmin(a.x(),b.x()),std::fmin(a.y(),b.y()),std::min(a.z(),b.z()));
auto max = Point3(std::fmax(a.x(),b.x()),std::fmax(a.y(),b.y()),std::fmax(a.z(),b.z()));

定义轴向量

auto dx = vec3(max.x() - min.x() , 0 , 0 );
auto dy = vec3(0 , max.y() - min.y() , 0 );
auto dz = vec3(0 , 0 , max.z() - min.z());

这里我们按照正对一个面的左边的点来定义起始的位置，然后定义每个面的轴

inline shared_ptr<hittable_list> box(const Point3& a,const Point3& b,shared_ptr<material> mat){
    auto sides = make_shared<hittable_list>();
    auto min = Point3(std::fmin(a.x(),b.x()),std::fmin(a.y(),b.y()),std::min(a.z(),b.z()));
    auto max = Point3(std::fmax(a.x(),b.x()),std::fmax(a.y(),b.y()),std::fmax(a.z(),b.z()));

    auto dx = vec3(max.x() - min.x() , 0 , 0 );
    auto dy = vec3(0 , max.y() - min.y() , 0 );
    auto dz = vec3(0 , 0 , max.z() - min.z());

    sides->add(make_shared<quad>(Point3(min.x(),min.y(),max.z()),dx,dy,mat)); // front
    sides->add(make_shared<quad>(Point3(min.x(),min.y(),min.z()),dz,dy,mat)); //left
    sides->add(make_shared<quad>(Point3(max.x(),min.y(),min.z()),-dx,dy,mat));//back
    sides->add(make_shared<quad>(Point3(max.x(),min.y(),max.z()),-dz,dy,mat));//right
    sides->add(make_shared<quad>(Point3(min.x(),max.y(),max.z()),dx,-dz,mat));//up
    sides->add(make_shared<quad>(Point3(min.x(),min.y(),min.z()),dx,dz,mat)); //bottom
    return sides;
}

在cornell_box中加上两句

void cornell_box(){
    hittable_list world;
    auto red   = make_shared<lambertian>(color(.65, .05, .05));
    auto white = make_shared<lambertian>(color(.73, .73, .73));
    auto green = make_shared<lambertian>(color(.12, .45, .15));
    auto light = make_shared<diffuse_light>(color(15, 15, 15));
    world.add(make_shared<quad>(Point3(555,0,0),vec3(0,555,0),vec3(0,0,555),green));
    world.add(make_shared<quad>(Point3(0,0,0),vec3(0,555,0),vec3(0,0,555),red));
    world.add(make_shared<quad>(Point3(343,544,332),vec3(-130,0,0),vec3(0,0,-105),light));
    world.add(make_shared<quad>(Point3(0,0,0),vec3(555,0,0),vec3(0,0,555),white));
    world.add(make_shared<quad>(Point3(555,555,555),vec3(-555,0,0),vec3(0,0,-555),white));
    world.add(make_shared<quad>(Point3(0,0,555),vec3(555,0,0),vec3(0,555,0),white));
    world.add(box(Point3(130,0,65),Point3(295,165,230),white));
    world.add(box(Point3(265,0,295),Point3(430,330,460),white));

在真实的Cornell Box中这两个盒子是有不同程度的倾斜的。所以我们需要对他进行旋转等操作。

平移

原文中：

在图形学中，通常我们会对对象应用变换（如平移、旋转、缩放）来改变它们在场景中的位置和方向。但在射线追踪中，有一种更加简单且有效的方法：不对对象进行变换，而是对射线进行逆变换。这种方法的优势在于计算上更为简便，特别是在光线与物体的交点测试中。

我的想法是这样。

  1. 假设我们从相机的原点然后在viewport中选择一个像素，射出射线，得到一个方向。这个像素射出的射线假设是没有能够和这个物体形成交点的。
  2. 然后我们的物体假设往这个像素的方向进行了位移，那么这个像素发出的射线就会打到这个物体上。

那么上面的事件等价于什么呢？

  1. 物体不动
  2. 首先明确一点，因为我们还是在做基于相机原点射向物体求交点。那么这个射线方向不能变。此时如果将相机的原点位置向物体平移的反方向位移。那么射线就会整体向反方向移动，就会与物体相交于相同的点。

代码

我们单独定义一个类来记录这样的一个平移的情况

class translate : public hittable{
public:
translate(shared_ptr<hittable> object,const vec3& offset) : object(object),offset(offset){
    bbox = object->bounding_box() + offset;
}
bool hit(const Ray& r,interval ray_t,hit_record& rec) const override{
    Ray offset_r(r.origin()-offset,r.direction(),r.time());
    if(!object->hit(offset_r,ray_t,rec)){
        return false;
    }
    rec.p+=offset;
    return true;
}
aabb bounding_box() const {
    return bbox;
}
private:
shared_ptr<hittable> object;
vec3 offset;
aabb bbox;
};

对于这个物体发生了平移了以后，其包围盒肯定也是要发生平移的。对于包围盒的加。我们需要以下几个重载

aabb operator + (const aabb& bbox,const vec3& offset){
    return aabb(bbox.x+offset.x(),bbox.y+offset.y(),bbox.z+offset.z());
}
aabb operator + (const vec3& offset,const aabb& bbox){
    return bbox + offset;
}
interval operator + (const interval& ival,const double& displacement){
    return interval(ival.min + displacement,ival.max+displacement);
}
interval operator + (const double& displacement,const interval& ival){
    return ival + displacement;
}

旋转

旋转理论上来说可以与轴对齐。

绕着z轴进行旋转。

绕着不同轴的旋转公式如下：

那么就可以得到不同的轴的旋转公式的表达。当绕着Z轴变化的时候：

绕着X轴旋转：

绕着Y轴旋转：

将平移视为初始光线的简单移动是理解发生的事情的一个好方法。但是，对于像旋转这样更复杂的操作，很容易不小心搞混项（或者忘记负号），因此，将旋转视为坐标系的变换会更好。

上述描述了以下移动过程：

  1. 将光线向后移动偏移量。
  2. 确定沿偏移光线是否存在交点（如果存在，在哪里）。
  3. 将交点向前移动偏移量。

但这也可以用坐标系变换来理解：

  1. 将光线从世界空间变换到物体空间。
  2. 确定在物体空间中是否存在交点（如果存在，在哪里）。
  3. 将交点从物体空间变换回世界空间。

旋转一个物体不仅会改变交点的位置，还会改变表面法向量，这将改变反射和折射的方向。所以我们也需要改变法线。幸运的是，法线会像向量一样旋转，所以我们可以使用上面的公式。虽然对于正在旋转和平移的物体，法线和向量看起来可能相同，但是正在缩放的物体需要特别注意以保持法线与表面正交。

我们需要开始将光线从世界空间变换到物体空间，对于旋转来说，这意味着通过-θ旋转。下面是对于y轴旋转，变化到物体的坐标系：

对于这个什么坐标系，我个人认为是保持目标不变，其它物体的相对目标的变化操作。那么我们要保证物体在世界坐标中的旋转，实际上就是我们相对于物体的逆旋转。当我们的射线发生逆旋转得到了物体上的交点以后，那么回到世界坐标系中，实际上就是这个交点发生的正旋转。

代码

接下来在hittable中补上对y轴的旋转。

class rotate_y : public hittable{
public:
bool hit(const Ray& r,interval ray_t,hit_record &rec) const override{
    Point3 origin = r.origin();
    vec3 direction = r.direction();
    origin[0] = cos_theta * r.origin()[0] - sin_theta * r.origin()[2];
    origin[2] = sin_theta * r.origin()[0] + cos_theta * r.origin()[2];

    direction[0] = cos_theta * r.direction()[0] - sin_theta * r.direction()[2];
    direction[2] = sin_theta * r.direction()[0] + cos_theta * r.direction()[2];
    Ray rotated_r = Ray(origin,direction,r.time());

    if(!object->hit(rotated_r,ray_t,rec)) {return false;}
    auto p = rec.p;
    p[0] = cos_theta * rec.p[0] + sin_theta * rec.p[2];
    p[2] = - sin_theta * rec.p[0] + cos_theta * rec.p[2];

    auto normal = rec.normal;
    normal[0] = cos_theta * rec.normal[0] + sin_theta * rec.normal[2];
    normal[2] = - sin_theta * rec.normal[0] + cos_theta * rec.normal[2];

    rec.p = p;
    rec.normal = unit_vector(normal);
    return true;
}
private:
shared_ptr<hittable> object;
double sin_theta;
double cos_theta;
aabb bbox;
};

然后就是对传入的object进行修改bbox。修改思路：

  1. 首先初始化一个空的包围盒，也就是初始化最小轴集合，和最大轴集合。
  2. 然后对于之前的包围盒，求每一个边界顶点，计算每个顶点的新的位置。
  3. 然后根据新的顶点位置，更新最小轴集合，和最大轴集合
rotate_y(shared_ptr<hittable> object,double angle) : object(object){
    auto radians = degrees_to_radians(angle);
    sin_theta = std::sin(radians);
    cos_theta = std::cos(radians);
    bbox = object->bounding_box();

    vec3 min(infinity,infinity,infinity);
    vec3 max(-infinity,-infinity,-infinity);
    for(int i=0;i<2;i++){
        for(int j=0;j<2;j++){
            for(int k=0;k<2;k++){
                auto x = bbox.x.min * i + bbox.x.max * (1-i);
                auto y = bbox.y.min * j + bbox.y.max * (1-j);
                auto z = bbox.z.min * k + bbox.z.max * (1-k);

                auto newx = cos_theta * x + sin_theta * z;
                auto newz = -sin_theta * x + cos_theta * z;
                vec3 tester(newx,y,newz);
                for(int c =0 ; c < 3 ; c++){
                    min[c] = std::fmin(min[c] , tester[c]);
                    max[c] = std::fmax(max[c] , tester[c]);
                }
            }
        }
    }
    bbox = aabb(min,max);
}
class rotate_y : public hittable{
public:
rotate_y(shared_ptr<hittable> object,double angle) : object(object){
    auto radians = degrees_to_radians(angle);
    sin_theta = std::sin(radians);
    cos_theta = std::cos(radians);
    bbox = object->bounding_box();

    vec3 min(infinity,infinity,infinity);
    vec3 max(-infinity,-infinity,-infinity);
    for(int i=0;i<2;i++){
        for(int j=0;j<2;j++){
            for(int k=0;k<2;k++){
                auto x = bbox.x.min * i + bbox.x.max * (1-i);
                auto y = bbox.y.min * j + bbox.y.max * (1-j);
                auto z = bbox.z.min * k + bbox.z.max * (1-k);

                auto newx = cos_theta * x + sin_theta * z;
                auto newz = -sin_theta * x + cos_theta * z;
                vec3 tester(newx,y,newz);
                for(int c =0 ; c < 3 ; c++){
                    min[c] = std::fmin(min[c] , tester[c]);
                    max[c] = std::fmax(max[c] , tester[c]);
                }
            }
        }
    }
    bbox = aabb(min,max);
}
bool hit(const Ray& r,interval ray_t,hit_record &rec) const override{
    Point3 origin = r.origin();
    vec3 direction = r.direction();
    origin[0] = cos_theta * r.origin()[0] - sin_theta * r.origin()[2];
    origin[2] = sin_theta * r.origin()[0] + cos_theta * r.origin()[2];

    direction[0] = cos_theta * r.direction()[0] - sin_theta * r.direction()[2];
    direction[2] = sin_theta * r.direction()[0] + cos_theta * r.direction()[2];
    Ray rotated_r = Ray(origin,direction,r.time());

    if(!object->hit(rotated_r,ray_t,rec)) {return false;}
    auto p = rec.p;
    p[0] = cos_theta * rec.p[0] + sin_theta * rec.p[2];
    p[2] = - sin_theta * rec.p[0] + cos_theta * rec.p[2];

    auto normal = rec.normal;
    normal[0] = cos_theta * rec.normal[0] + sin_theta * rec.normal[2];
    normal[2] = - sin_theta * rec.normal[0] + cos_theta * rec.normal[2];

    rec.p = p;
    rec.normal = unit_vector(normal);
    return true;
}
aabb bounding_box() const override{ return bbox; }
private:
shared_ptr<hittable> object;
double sin_theta;
double cos_theta;
aabb bbox;
};

修改cornell_box

void cornell_box(){
    hittable_list world;
    auto red   = make_shared<lambertian>(color(.65, .05, .05));
    auto white = make_shared<lambertian>(color(.73, .73, .73));
    auto green = make_shared<lambertian>(color(.12, .45, .15));
    auto light = make_shared<diffuse_light>(color(15, 15, 15));
    world.add(make_shared<quad>(Point3(555,0,0),vec3(0,555,0),vec3(0,0,555),green));
    world.add(make_shared<quad>(Point3(0,0,0),vec3(0,555,0),vec3(0,0,555),red));
    world.add(make_shared<quad>(Point3(343,554,332),vec3(-130,0,0),vec3(0,0,-105),light));
    world.add(make_shared<quad>(Point3(0,0,0),vec3(555,0,0),vec3(0,0,555),white));
    world.add(make_shared<quad>(Point3(555,555,555),vec3(-555,0,0),vec3(0,0,-555),white));
    world.add(make_shared<quad>(Point3(0,0,555),vec3(555,0,0),vec3(0,555,0),white));
    shared_ptr<hittable> box1 = box(Point3(130,0,65),Point3(295,165,230),white);
    box1 = make_shared<rotate_y>(box1,15);
    box1 = make_shared<translate>(box1,vec3(265,0,295));
    world.add(box1);
    shared_ptr<hittable> box2 = box(Point3(0,0,0),Point3(165,165,165),white);
    box2 = make_shared<rotate_y>(box2,-18);
    box2 = make_shared<translate>(box2,vec3(130,0,65));
    world.add(box2);
    bvh_node bvh_root(world.objects,0,world.objects.size()-1);
    camera cam;

    cam.aspect_ratio      = 1.0;
    cam.image_width       = 600;
    cam.samples_per_pixel = 200;
    cam.max_depth         = 50;
    cam.background        = color(0,0,0);

    cam.vfov     = 40;
    cam.lookfrom = Point3(278, 278, -800);
    cam.lookat   = Point3(278, 278, 0);
    cam.vup      = vec3(0,1,0);

    cam.defocus_angle = 0;

    cam.render(bvh_root);
}

最终结果

头发掉光的程序员
关注
实例分割(Instance Segmentation)原理与代码实战案例讲解
AI天才研究院
05-30 1627
实例分割(Instance Segmentation)原理与代码实战案例讲解 作者：禅与计算机程序设计艺术 1. 背景介绍 1.1 实例分割的定义与意义 实例分割（Instance
Instance Segmentation原理与代码实例讲解
AI大模型应用之禅
06-25 891
Instance Segmentation原理与代码实例讲解 1.背景介绍 在计算机视觉领域，图像分割是一项重要的任务。图像分割可以分为语义分割和实例分割。语义分割的目标是将图像中的每个像素分类到一个特定的类别，而实例分割不仅要分类，还要区分同一类别中的不同实例。
matlab instance_哈夫曼_
09-29
在本案例中，我们讨论的是一个MATLAB实现的哈夫曼编码实例。 哈夫曼编码的基本步骤包括以下几个方面： 1. **统计字符频率**：首先，我们需要统计输入文本中各个字符出现的频率。这一步通常通过遍历文本并计数来...
DB2安装及创建Instance
09-04
本案例中提到的是命令行模式的静默安装，这种方式适合自动化部署或者在没有图形界面的服务器上进行。 在开始安装前，确保满足DB2的硬件和软件需求，例如操作系统兼容性、内存和磁盘空间等。然后，下载对应的DB2...
terraform案例terraform案例
06-12
在这个“terraform案例”中，我们将探讨如何使用Terraform与Go语言配合，以及在阿里云（Alibaba Cloud，简称 Alicloud）上部署资源。 首先，了解Terraform的基本概念至关重要。Terraform的配置文件通常以`.tf`为...
黑马java学习笔记14(阶段二 第四章4-3 99~4-4)
xiaozhuzhu__的博客
10-11 440
黑马java学习笔记14(阶段二 第四章4-3 99~4-4)
利用编程思维做题之反转链表
跟着信仰走
10-11 701
通过上述步骤，培养我们理解题目、分析题目到解决题目的思维，确定解决方案且成功实现了代码。抽象出这种方法，它不仅适用于链表反转的问题，也可以推广到其他需要遍历和修改链表结构的情况。
DS线性表之带头双向循环链表的讲解和实现(3)
tan180°的博客
10-14 704
前文所讲的是不带头单向不循环链表，三个条件都相反的带头循环链表就是我们今天所要讲的内容它也很常用，所以我们有必要好好了解它一下我们发现此链表虽然听起来复杂，但是实现起来竟然比单链表好很多，这其实启发我们不要被事物的表面所吓到，说不定再撑一会儿，就拨云见日了呢~
【C++】拆分详解 - list
bubble_shadow的博客
10-14 449
底层是带头双向链表结构，需要额外空间保存节点信息（对于存储类型较小元素的大list来说这可能是一个重要的因素）在常数范围内支持任意位置的插入和删除，效率通常优于array、vector和deque。不支持随机访问，必须从头/尾开始找，访问特定元素需要线性时间。
C语言01
2302_76384361的博客
10-14 263
/获取顺序表的大小，该接口直接获取顺序表的成员变量size并返回。//顺序表的索引，给出索引求值。//修改顺序表中指定位置的值。//顺序表的插入操作。//顺序表的查找操作。
数据结构 -- 跳表
分享技术，分享经验
10-11 790
它可以看作是链表与二分查找的结合体，能够在保持数据有序的同时，实现快速的查找，时间复杂度与平衡树（如红黑树）相同，但实现上更为简单。，但是其底层结构需要维护多个层次的节点分裂、合并等复杂操作，特别是在插入和删除时，涉及平衡和重构，带来较高的性能成本。，但其结构更简单，动态操作（如插入、删除、更新）的实现也更加直接，符合 Redis 追求简洁高效的设计理念。删除操作与查找操作类似，从最高层开始查找需要删除的元素，找到元素后，在每一层级的链表中删除该元素的索引。：Redis 的有序集合为什么不使用B+树？
利用编程思维做题之链表内指定区间反转
跟着信仰走
10-11 722
通过上述方法，我们成功实现了对单链表指定区间的节点进行反转的操作。关键在于正确定位需要反转的区间，并在反转过程中维护好前后节点的连接关系。此方法不仅有效解决了本题，还可以应用于其他涉及链表部分反转或节点调整的题目。熟练掌握链表操作和指针的使用，对于处理类似问题至关重要。
使用切面来记录接口日志
weixin_45014721的博客
10-14 42
*** @description: 接口日志结构化解析(接口方法中使用)* @author:/*** 服务注册中接口配置发布地址的namespace* @return/*** 服务注册中接口配置发布地址的serverCode* @return/*** 服务注册中接口配置发布地址的serverName* @return/*** 服务注册中接口配置发布地址的interfaceCode* @return/*** 服务注册中接口配置发布地址的interfaceUrl。
杨中科 .netcore Linq常用的扩展方法
weixin_43847546的博客
10-11 901
LINQ中提供了大量类似Where的扩展方法，简化数据处理。大部分都在System.Linq命名空间中数组、List、Dictionary、Set… 都是实现了。因此都是可以使用这些扩展方法。
Stream流 学习笔记
Dennis_nafla的博客
10-14 358
为了提高程序员对数组和集合的操作便利性而推出的操作--Stream流。
接口中的静态常量在项目中的使用，以及固长列表和变长列表
ll2695015910的博客
10-14 753
因为这是接口内的定义，而我们并没有主动去加上权限修饰，出于接口出现的意义，那在 Java 接口内定义的字段默认会有：默认静态，默认常量，默认公共权限。但是，ALL 是一个可变的 ArrayList，它本身的引用不能变，但这个 ArrayList 可以修改其内容，因此你可以对它调用 add() 等修改操作。当使用 Arrays.asList() 方法时，返回的是一个固定大小的列表，这个列表不能改变大小，但它的内容（元素）是可以修改的。这种列表的大小是不可变的，意味着你不能对它进行修改，如添加或删除元素。
智能指针及其应用
weixin_46366676的博客
10-14 460
但是，引用计数带来了很多问题，下面将把这些问题提出，并给出shared_ptr解决问题的设计方案。
Sql语句解析工具类
code_nn的博客
10-11 297
Sql语句解析工具类，利用第三方依赖，根据sql解析获取表名称
TS中的接口、泛型、自定义类型 与vue3的使用
最新发布
qq_58341172的博客
10-14 203
首先，我们在之前创建的文件中，创建自定义的类型type,切记一定要export否则，在另一个文件中不能引入该类型//定义一个接口，用于限制person对象的具体属性id:string,age:number//自定义类型// 定义数组的两种方式export interface PersonListInterface{ //定义一个接口//@指从src路径开始 ，与上面语法等价//方式三：{id:"123",name:"张三",age:18},
请介绍下python traitles Instance, 并结合案例说明
05-31
Traitless Instance 是指一个没有任何trait属性的实例对象。在 Python 中，Traitless Instance 的使用可以通过定义一个空的 Trait 类来实现。 下面是一个简单的示例代码： ```python from traits.api import ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值