（转载）在C++程序中使用pbrt进行渲染

最新推荐文章于 2024-08-15 09:31:26 发布
最新推荐文章于 2024-08-15 09:31:26 发布
阅读量1.2k 收藏
点赞数
分类专栏： pbrt

近段时间做一个关于水面的动画。由于我用c++实现水面动画的，然而使用c++我自己的渲染系统渲染结果被同学说是可视化不叫渲染，所以我决定修改一下……

恰好进来在学习pbrt，所以索性就蛋疼了考虑直接用pbrt来渲染吧……（至于为什么，仅为好玩儿……）

pbrt默认的渲染方式是使用一个场景描述文件.pbrt，我要渲染的对象是三角网络就必须使用对应的描述语句定义三角对象：

复制代码 
Shape "trianglemesh"  

"integer indices" [0 2 1 ] 

"point P" [0 0 0.401925 2 0 0.92604 0 2 0.950944 ] 

"normal N" [-0.245007 -0.256649 0.934935 -0.439362 -0.242124 0.865065 -0.228464 -0.466945 0.854264 ]
复制代码

对应的参数都很清晰不多说了，我的方法就是将我的三角网络拆成三角形按照这个格式一个一个输出到文件，mesh.pbrt：

复制代码 
Shape "trianglemesh"  "integer indices" [0 2 1 ] "point P" [0 0 0.401925 2 0 0.92604 0 2 0.950944 ] "normal N" [-0.245007 -0.256649 0.934935 -0.439362 -0.242124 0.865065 -0.228464 -0.466945 0.854264 ]
Shape "trianglemesh"  "integer indices" [0 2 1 ] "point P" [2 0 0.92604 2 2 1.48582 0 2 0.950944 ] "normal N" [-0.439362 -0.242124 0.865065 -0.387612 -0.436964 0.811677 -0.228464 -0.466945 0.854264 ]
Shape "trianglemesh"  "integer indices" [0 2 1 ] "point P" [2 0 0.92604 4 0 1.41771 2 2 1.48582 ] "normal N" [-0.439362 -0.242124 0.865065 -0.371551 -0.220212 0.901918 -0.387612 -0.436964 0.811677 ]
......
复制代码

按照pbrt给出的例子写出场景主文件：

复制代码 
#定义表面积分器
SurfaceIntegrator "directlighting"
#transform
ConcatTransform [ 0.828849 -0.295370 -0.475149 0.000000 -0.559473 -0.437585 -0.703924 0.000000 -0.000000 0.849280 -0.527943 0.000000 0.000000 0.000000 0.000000 1.000000 ]
Translate -4.860000 -7.200000 -5.400000
#定义摄像机
Camera "perspective" "float fov" [90.00000 ] "float shutteropen" [0.000000 ] "float shutterclose" [0.000000 ] "float screenwindow" [-1.000000 1.000000 -1.000000 1.000000 ] "float frameaspectratio" [1.333333 ] 
#定义胶片
Film "image" "integer xresolution" [200 ] "integer yresolution" [200 ] 
     "string filename" "1.exr"
#定义采样器
Sampler "lowdiscrepancy" "integer pixelsamples" [8]
PixelFilter "box"


WorldBegin
AttributeBegin
LightSource "infinite" "string mapname" ["textures/skylight-dusk.exr"]
"color L" [0.5 0.5 0.5]
    "integer nsamples" [16]
AttributeEnd

AttributeBegin
#mesh的材质
Material "uber" "color Kd" [0 0.1 0.15] "color Kr" [0.9 0.9 0.9] "color Ks" [0.1 0.1 0.1] "float roughness" [0.9] "float index" [1.34]
#mesh trnsform
Translate -90 -80 -2
Scale 0.1 0.1 0.3
#包含mesh
Include "mesh.pbrt"
AttributeEnd

WorldEnd
复制代码

（更多的pbrt场景命令你可以去官网下文档来看）

执行下列命令(当然你要先编译好pbrt，这个直接下pbrt-v2编译就好，没什么需要说明的地方)：

pbrt scene.pbrt

执行pbrt就会出现一个进度条开始渲染对象，渲染完成后就会在当前目录输出一个1.exr图像。

但是我要做的是动画，每帧mesh有至少有N*N*2个三角面，N>=512，我的动画打算30秒，20帧，一共600张图，需要600个mesh，这个要是手动来一个一个搞，别说mesh输出一共要600*100M+，就是人也要累死啊。

考虑用写个批处理来搞一下感觉也不好使，后来反正因为学习pbrt就决定把pbrt的代码嵌入到c++程序中去算了。

pbrt代码本身唯一的文档，就是pbrt那本书了，但是型号它的API很清晰易懂，几乎每个api都是场景描述文件对应的，所以我只需要把场景pbrt文件翻译成c++代码就可以调用pbrt了，pbrt的API如下：

复制代码 
void pbrtInit(const Options &opt);
void pbrtCleanup();
void pbrtIdentity();
void pbrtTranslate(float dx, float dy, float dz);
void pbrtRotate(float angle, float ax, float ay, float az);
void pbrtScale(float sx, float sy, float sz);
void pbrtLookAt(float ex, float ey, float ez,float lx, float ly, float lz,float ux, float uy, float uz);
void pbrtConcatTransform(float transform[16]);
void pbrtTransform(float transform[16]);
void pbrtCoordinateSystem(const string &);
void pbrtCoordSysTransform(const string &);
void pbrtActiveTransformAll();
void pbrtActiveTransformEndTime();
void pbrtActiveTransformStartTime();
void pbrtTransformTimes(float start, float end);
void pbrtPixelFilter(const string &name, const ParamSet &params);
void pbrtFilm(const string &type, const ParamSet &params);
void pbrtSampler(const string &name, const ParamSet &params);
void pbrtAccelerator(const string &name, const ParamSet &params);
void pbrtSurfaceIntegrator(const string &name, const ParamSet &params);
void pbrtVolumeIntegrator(const string &name, const ParamSet &params);
void pbrtRenderer(const string &name, const ParamSet &params);
void pbrtCamera(const string &, const ParamSet &cameraParams);
void pbrtWorldBegin();
void pbrtAttributeBegin();
void pbrtAttributeEnd();
void pbrtTransformBegin();
void pbrtTransformEnd();
void pbrtTexture(const string &name, const string &type,const string &texname, const ParamSet &params);
void pbrtMaterial(const string &name, const ParamSet &params);
void pbrtMakeNamedMaterial(const string &name, const ParamSet &params);
void pbrtNamedMaterial(const string &name);
void pbrtLightSource(const string &name, const ParamSet &params);
void pbrtAreaLightSource(const string &name, const ParamSet &params);
void pbrtShape(const string &name, const ParamSet &params);
void pbrtReverseOrientation();
void pbrtVolume(const string &name, const ParamSet &params);
void pbrtObjectBegin(const string &name);
void pbrtObjectEnd();
void pbrtObjectInstance(const string &name);
void pbrtWorldEnd();
复制代码

对比一下场景描述文件，发现基本一一对应。

pbrt本身是被编译成lib静态库的，而pbrt.exe仅仅是一个引用pbrtlib的单文件c++程序而已：

复制代码 
#include "stdafx.h"
#include "api.h"
#include "probes.h"
#include "parser.h"
#include "parallel.h"

// main program
int main(int argc, char *argv[]) {
    Options options;
    vector<string> filenames;
    // Process command-line arguments
    for (int i = 1; i < argc; ++i) {
        if (!strcmp(argv[i], "--ncores")) options.nCores = atoi(argv[++i]);
        else if (!strcmp(argv[i], "--outfile")) options.imageFile = argv[++i];
        else if (!strcmp(argv[i], "--quick")) options.quickRender = true;
        else if (!strcmp(argv[i], "--quiet")) options.quiet = true;
        else if (!strcmp(argv[i], "--verbose")) options.verbose = true;
        else if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) {
            printf("usage: pbrt [--ncores n] [--outfile filename] [--quick] [--quiet] "
                   "[--verbose] [--help] <filename.pbrt> ...\n");
            return 0;
        }
        else filenames.push_back(argv[i]);
    }

    // Print welcome banner
    if (!options.quiet) {
        printf("pbrt version %s of %s at %s [Detected %d core(s)]\n",
               PBRT_VERSION, __DATE__, __TIME__, NumSystemCores());
        printf("Copyright (c)1998-2014 Matt Pharr and Greg Humphreys.\n");
        printf("The source code to pbrt (but *not* the book contents) is covered by the BSD License.\n");
        printf("See the file LICENSE.txt for the conditions of the license.\n");
        fflush(stdout);
    }
    pbrtInit(options);
    // Process scene description
    PBRT_STARTED_PARSING();
    if (filenames.size() == 0) {
        // Parse scene from standard input
        ParseFile("-");
    } else {
        // Parse scene from input files
        for (u_int i = 0; i < filenames.size(); i++)
            if (!ParseFile(filenames[i]))
                Error("Couldn't open scene file \"%s\"", filenames[i].c_str());
    }
    pbrtCleanup();
    return 0;
}
复制代码

其中起到解析文件作用就是如下这段：

复制代码 
    pbrtInit(options);
    // Process scene description
    PBRT_STARTED_PARSING();
    if (filenames.size() == 0) {
        // Parse scene from standard input
        ParseFile("-");
    } else {
        // Parse scene from input files
        for (u_int i = 0; i < filenames.size(); i++)
            if (!ParseFile(filenames[i]))
                Error("Couldn't open scene file \"%s\"", filenames[i].c_str());
    }
复制代码

它是使用yacc解析的，细节我并不懂，我把这个文件换成如下：

复制代码 
#include "stdafx.h"
#include "api.h"
#include "probes.h"
#include "parser.h"
#include "parallel.h"
#include "paramset.h"

extern void InitParamSet(ParamSet &ps, SpectrumType);

void create_a_tri(
    Point i1,Point i2,Point i3,
    Normal n1,Normal n2,Normal n3
    )
{
    ParamSet params;
    //mesh参数
    int s[3] = {0,2,1};
    params.AddInt("indices",s,3);
    Point p[3] = {i1,i2,i3};
    params.AddPoint("P",p,3);
    Normal n[3] = {n1,n2,n3};
    params.AddNormal("N",n,3);
    pbrtShape("trianglemesh",params);
}

int main(int argc, char *argv[]) 
{
    Options opt;
    opt.imageFile = "1.exr";
    opt.nCores = 4;
    opt.openWindow = false;
    opt.quickRender = false;
    pbrtInit(opt);

    
    ParamSet params;
    /*
    InitParamSet(params, SPECTRUM_REFLECTANCE);
    pbrtSurfaceIntegrator("directlighting",params);
    */

    //初始化所有参数
    //表面积分器参数
    int maxdepth = 5;
    params.AddInt("maxdepth",&maxdepth,1);
    string strategy = "all";
    params.AddString("strategy",&strategy,1);



    //相机参数
    float fov = 90;
    params.AddFloat("fov",&fov,1);
    float shutteropen = 0.00f;
    params.AddFloat("shutteropen",&shutteropen,1);
    float shutterclose = 0.00f;
    params.AddFloat("shutterclose",&shutterclose,1);
    float screenwindow[4] = {-1.0,1.0,-1.0,1.0};
    params.AddFloat("screenwindow",screenwindow,4);
    float ratio = 1.333333;
    params.AddFloat("frameaspectratio",&ratio,1);
    //胶片
    int xresolution = 640;
    int yresolution = 480;
    string filename = "1.exr";
    params.AddInt("xresolution",&xresolution,1);
    params.AddInt("yresolution",&yresolution,1);
    params.AddString("filename",&filename,1);
    //采样器
    int pixelsample = 8;
    params.AddInt("pixelsamples",&pixelsample,1);
    //过滤器
    float xwidth = 0.5;
    float ywidth = 0.5;
    params.AddFloat("xwith",&xwidth,1);
    params.AddFloat("ywith",&ywidth,1);
    //光照
    float L[3] = {0.5,0.5,0.5};
    int nsamples = 16;
    string mapname = "textures/skylight-dusk.exr";
    params.AddRGBSpectrum("L",L,3);
    params.AddInt("nsamples",&nsamples,1);
    params.AddString("mapname",&mapname,1);
    //材质
    float Kd[3] = {0,0.1,0.15};
    float Kr[3] = {0.9,0.9,0.9};
    float Ks[3] = {0.1,0.1,0.1};
    float roughness = 0.9;
    float index = 1.34;
    params.AddRGBSpectrum("Kd",Kd,3);
    params.AddRGBSpectrum("Kr",Kr,3);
    params.AddRGBSpectrum("Ks",Ks,3);
    params.AddFloat("roughness",&roughness,1);
    params.AddFloat("index",&index,1);




    pbrtSurfaceIntegrator("directlighting",params);
    float ct[16] = {0.828849,-0.295370,-0.475149,0.000000,-0.559473,-0.437585,-0.703924,0.000000,-0.000000,0.849280,-0.527943,0.000000,0.000000,0.000000,0.000000,1.000000};
    pbrtConcatTransform(ct);
    pbrtTranslate(-4.860000,-7.200000,-5.400000);
    pbrtCamera("perspective",params);
    pbrtFilm("image",params);
    pbrtSampler("lowdiscrepancy",params);
    pbrtPixelFilter("box",params);

    pbrtWorldBegin();
    pbrtAttributeBegin();
    pbrtLightSource("infinite",params);
    pbrtAttributeEnd();

    pbrtAttributeBegin();
    pbrtMaterial("uber",params);
    //pbrtTranslate(-90,-80,-2);
    //pbrtScale(0.1,0.1,0.4);
    pbrtTranslate(-1,-1,-9);
    pbrtScale(1,1,1);
    //mesh参数
    int s[3] = {0,2,1};
    params.AddInt("indices",s,3);
    Point p[3] = {Point(0,0,11.8604),Point(2,0,11.2012),Point(0,2,11.2039)};
    params.AddPoint("P",p,3);
    Normal n[3] = {Normal(13.1851,13.1312,40),Normal(25.1371,13.4084,40),Normal(13.4624,25.8694,40)};
    params.AddNormal("N",n,3);
    pbrtShape("trianglemesh",params);

    create_a_tri(Point(0,0,11.8604),Point(2,0,11.2012),Point(0,2,11.2039),Normal(13.1851,13.1312,40),Normal(25.1371,13.4084,40),Normal(13.4624,25.8694,40));
    create_a_tri(Point(2,0,11.2012),Point(2,2,10.5308),Point(0,2,11.2039),Normal(25.1371,13.4084,40),Normal(21.2989,23.2563,40),Normal(13.4624,25.8694,40));
    pbrtAttributeEnd();

    pbrtWorldEnd();

    pbrtCleanup();
    return 0;
}
复制代码

很好，和pbrt文件渲染出来类似结果。

有了这些就可以把它嵌入到of中了，定义两个函数：

复制代码 
void create_a_tri(
    Point i1,Point i2,Point i3,
    Normal n1,Normal n2,Normal n3
    );

int render(const char* file_name,FloatPixels** pxs,int N,float LL,float lamda,float nla);
复制代码

第一个创建一个三角形，第二个就是使用c++创建pbrt场景渲染输出。实现一下：

复制代码 
#include "render.h"
#include "core\stdafx.h"
#include "core\api.h"
#include "core\probes.h"
#include "core\parser.h"
#include "core\parallel.h"
#include "core\paramset.h"



void create_a_tri(
    Point i1,Point i2,Point i3,
    Normal n1,Normal n2,Normal n3
    )
{
    ParamSet params;
    //mesh参数
    int s[3] = {0,2,1};
    params.AddInt("indices",s,3);
    Point p[3] = {i1,i2,i3};
    params.AddPoint("P",p,3);
    Normal n[3] = {n1,n2,n3};
    params.AddNormal("N",n,3);
    pbrtShape("trianglemesh",params);
}

int render(const char* file_name,FloatPixels** pxs,int N,float LL,float lamda,float nla) 
{
    printf("Generating Mesh...\n");
    Options opt;
    opt.nCores = 4;
    opt.openWindow = false;
    opt.quickRender = false;
    pbrtInit(opt);
    
    ParamSet params;

    //初始化所有参数
    //表面积分器参数
    int maxdepth = 5;
    params.AddInt("maxdepth",&maxdepth,1);
    string strategy = "all";
    params.AddString("strategy",&strategy,1);

    //相机参数
    float fov = 120;
    params.AddFloat("fov",&fov,1);
    float shutteropen = 0.00f;
    params.AddFloat("shutteropen",&shutteropen,1);
    float shutterclose = 0.00f;
    params.AddFloat("shutterclose",&shutterclose,1);
    float screenwindow[4] = {-1.0,1.0,-1.0,1.0};
    params.AddFloat("screenwindow",screenwindow,4);
    float ratio = 1.333333;
    params.AddFloat("frameaspectratio",&ratio,1);
    //胶片
    int xresolution = 200;
    int yresolution = 200;
    string filename = file_name;
    params.AddInt("xresolution",&xresolution,1);
    params.AddInt("yresolution",&yresolution,1);
    params.AddString("filename",&filename,1);
    //采样器
    int pixelsample = 4;
    params.AddInt("pixelsamples",&pixelsample,1);
    //过滤器
    float xwidth = 0.5;
    float ywidth = 0.5;
    params.AddFloat("xwith",&xwidth,1);
    params.AddFloat("ywith",&ywidth,1);
    //光照
    float L[3] = {0.5,0.5,0.5};
    int nsamples = 4;
    string mapname = "textures/skylight-dusk.exr";
    params.AddRGBSpectrum("L",L,3);
    params.AddInt("nsamples",&nsamples,1);
    params.AddString("mapname",&mapname,1);
    //材质
    float Kd[3] = {0,0.1,0.15};
    float Kr[3] = {0.9,0.9,0.9};
    float Ks[3] = {0.1,0.1,0.1};
    float roughness = 0.9;
    float index = 1.34;
    params.AddRGBSpectrum("Kd",Kd,3);
    params.AddRGBSpectrum("Kr",Kr,3);
    params.AddRGBSpectrum("Ks",Ks,3);
    params.AddFloat("roughness",&roughness,1);
    params.AddFloat("index",&index,1);

    pbrtSurfaceIntegrator("directlighting",params);
    float ct[16] = {0.828849,-0.295370,-0.475149,0.000000,-0.559473,-0.437585,-0.703924,0.000000,-0.000000,0.849280,-0.527943,0.000000,0.000000,0.000000,0.000000,1.000000};
    pbrtConcatTransform(ct);
    pbrtTranslate(-4.860000,-7.200000,-5.400000);
    pbrtCamera("perspective",params);
    pbrtFilm("image",params);
    pbrtSampler("lowdiscrepancy",params);
    pbrtPixelFilter("box",params);

    pbrtWorldBegin();
    pbrtAttributeBegin();
    pbrtLightSource("infinite",params);
    pbrtAttributeEnd();

    pbrtAttributeBegin();
    pbrtMaterial("uber",params);
    pbrtTranslate(-80,-80,-3);
    pbrtScale(0.1,0.1,0.1);

    for(int i=0;i<N-1;i++)
    {
        for(int j=0;j<N-1;j++)
        {

                create_a_tri(
                    Point((j+lamda*pxs[0]->getColor(j,i).r)*LL/N,(i+lamda* pxs[1]->getColor(j,i).r)*LL/N,pxs[2]->getColor(j,i).r*N/2),
                    Point((j+1+lamda*pxs[0]->getColor(j+1,i).r)*LL/N,(i+lamda* pxs[1]->getColor(j+1,i).r)*LL/N,pxs[2]->getColor(j+1,i).r*N/2),
                    Point((j+lamda*pxs[0]->getColor(j,i+1).r)*LL/N,(i+1+lamda* pxs[1]->getColor(j,i+1).r)*LL/N,pxs[2]->getColor(j,i+1).r*N/2),
                    Normal(nla*pxs[3]->getColor(j,i).r,nla*pxs[3]->getColor(j,i).g,nla*pxs[3]->getColor(j,i).b),
                    Normal(nla*pxs[3]->getColor(j+1,i).r,nla*pxs[3]->getColor(j+1,i).g,nla*pxs[3]->getColor(j+1,i).b),
                    Normal(nla*pxs[3]->getColor(j,i+1).r,nla*pxs[3]->getColor(j,i+1).g,nla*pxs[3]->getColor(j,i+1).b)
                    );
                create_a_tri(
                    Point((j+1+lamda*pxs[0]->getColor(j+1,i+1).r)*LL/N,(i+1+lamda* pxs[1]->getColor(j+1,1+i).r)*LL/N,pxs[2]->getColor(j+1,i+1).r*N/2),
                    Point((j+1+lamda*pxs[0]->getColor(j+1,i).r)*LL/N,(i+lamda* pxs[1]->getColor(j+1,i).r)*LL/N,pxs[2]->getColor(j+1,i).r*N/2),
                    Point((j+lamda*pxs[0]->getColor(j,i+1).r)*LL/N,(i+1+lamda* pxs[1]->getColor(j,i+1).r)*LL/N,pxs[2]->getColor(j,i+1).r*N/2),
                    Normal(nla*pxs[3]->getColor(j+1,i+1).r,nla*pxs[3]->getColor(j+1,i+1).g,nla*pxs[3]->getColor(j+1,i+1).b),
                    Normal(nla*pxs[3]->getColor(j+1,i).r,nla*pxs[3]->getColor(j+1,i).g,nla*pxs[3]->getColor(j+1,i).b),
                    Normal(nla*pxs[3]->getColor(j,i+1).r,nla*pxs[3]->getColor(j,i+1).g,nla*pxs[3]->getColor(j,i+1).b)
                    );
        }
    }
    pbrtAttributeEnd();
    pbrtWorldEnd()；
    pbrtCleanup();
    return 0;
}
复制代码

虽然这样效率比较低，但是至少可以脱手了。

每帧我们计算完动画，自动调用render函数，就可以在无人看守下出图了。

最后，关于pbrt中关于图形学的内容就不细说了，东西都写在pbrt里面，uber材质是一种综合材质。

放2张图结尾吧：

xuexiaokkk
关注
专栏目录
pbrt3在windows10环境中的编译、安装及测试教程
qq_44010594的博客
03-04 2113
介绍 由于上高级计算机图形学课程接触了pbrt。pbrt-v3对应的教材是Physically Based Rendering：From Theory to Implementation, Third Edition。pbrt官网 安装过程 环境 本人使用计算机环境为windows10, VS2017。 步骤 pbrt源码链接：https://github.com/mmp/pbrt-v3。推荐下...
【pbrt】在c++程序中使用pbrt进行渲染
weixin_30700099的博客
05-26 317
近段时间做一个关于水面的动画。由于我用c++实现水面动画的，然而使用c++我自己的渲染系统渲染结果被同学说是可视化不叫渲染，所以我决定修改一下…… 恰好进来在学习pbrt，所以索性就蛋疼了考虑直接用pbrt来渲染吧……（至于为什么，仅为好玩儿……） pbrt默认的渲染方式是使用一个场景描述文件.pbrt，我要渲染的对象是三角网络就必须使用对应的描述语句定义三角对象： Shape "tri...
PBRT笔记(5)——相机模型
weixin_34362991的博客
12-06 207
Camera class Camera { public: //实现相机在一定时间内进行特定的运动 AnimatedTransform CameraToWorld; //快门开/关数据，可以用于计算动态模糊 const Float shutterOpen, shutterClose; //胶片类指针用于计算最终图像 Film *film; ...
探索pbrt：物理基础渲染的巅峰之作
最新发布
gitblog_00159的博客
08-15 642
探索pbrt：物理基础渲染的巅峰之作 pbrt-v3Source code for pbrt, the renderer described in the third edition of "Physically Based Rendering: From Theory To Implementation", by Matt Pharr, Wenzel Jakob, and Greg Humph...
pbrt v-4物理渲染编译
qq_41629249的博客
05-13 589
pbrt v-4物理渲染编译 写在掘金上面了，链接附上： https://juejin.cn/post/7097177087466799134
使用pbrt遇到的问题及解决方法
weixin_41659029的博客
08-10 472
1.如何将obj格式的文件转换为pbrt格式 首先找到pbrt路径下的 pbrt-v3\build\Release\obj2pbrt.exe，按住shift的同时点击鼠标右键，选择在此处打开Powershell窗口(s)。 在命令行输入以下命令.\obj2pbrt.exe .\p3dm.ru_A10.obj .\p3dm.ru_A10.pbrt，其中.\obj2pbrt.exe是我们要运行的可执行程序， .\p3dm.ru_A10.obj为要转换的obj文件路径...
pbrt-v4：pbrt的源代码，在即将出版的第四版“基于物理的渲染：从理论到实现”一书中描述了光线跟踪器
02-11
这是pbrt-v4的早期版本，该渲染系统将在（最终）即将出版的第四版《基于物理的渲染：从理论到实现》中进行介绍。 （我们希望能在2021年的几个月前发布该书的在线版本，并在2021年夏季发布印刷书籍。） 我们正在为...
pbrt-v3:pbrt的源代码，第三版“基于物理的渲染”中介绍的渲染器
04-12
该存储库包含pbrt版本的源代码，该版本在 ， 和Greg Humphreys的第三版《基于物理的渲染：从理论到实现》中进行了描述。 和以前一样，该代码在BSD许可下可用。 有有关基于物理的渲染书以及pbrt的许多其他资源的...
pbrt-v3.zip
06-20
光线追踪是一种计算图形学中的高级渲染技术，它模拟光在三维空间中的传播，通过追踪从眼睛发出的虚拟光线与场景中物体的交互来计算像素颜色。PBRT-v3的核心理念就是遵循物理上的光学原理，如反射、折射、吸收和散射...
pbrt-skin-bssrdf:Donner & Jensen 的“A Spectral BSSRDF for Shading Human Skin”在 PBRT 中的实现
06-10
《PBRT中Donner & Jensen的人皮肤BSSRDF实现详解》 PBRT，全称为“Physically ...通过深入研究这个实现，我们可以更全面地理解物理基础渲染中的关键概念，并在实际项目中应用这些知识，创造出更为真实的虚拟世界。
推导LookAt函数定义的视图矩阵
WhoisPo的专栏
09-10 3562
在OpenGL中需要定义一个视图(view)矩阵，很多库都提供一个叫LookAt的函数，可以定义该视图矩阵。 该函数的原型是 Mat4x4 LookAt(pos: vector3D, target: vector3D, up:vector3D) 直观的理解，就是pos为观察者当前的坐标，target朝向的点坐标，up为观察者上方方向。返回的就是一个视图矩阵。 其实所谓的视图矩阵，就是一个坐标系与坐标系之间的转换矩阵。视图矩阵将世界坐标系下的坐标转换到了视图坐标系下。 我们来推导一下三维坐标系转换的关系
lookAt函数
weixin_43283426的博客
05-08 2562
1lookAt函数的格式为lookAt(eye,at,up)，at与eye的差作为光线方向 2JavaScript中at与up必须定义为const常量，原因不明 3lookAt函数实则为模视变换的另一种写法 4在MV.js中lookAt的原型定义如下： function lookAt( eye, at, up ) { if ( !Array.isArray(eye) || eye.length !...
关于 lookat函数的问题
qq_43212498的博客
10-26 482
今天玩unity的时候，突然发现调用lookat函数的时候，物体有个问题，那就是始终用z轴面对目标，那假如我们想要用其他轴来面对目标物体有没有办法呢？ 先来看看这个方法： transform.LookAt(Vector targetpositon); 当物体调用这个方法后，物体的Z轴就会朝向这个传进去的参数物体所在的位置。 那么怎么改变轴向呢？ 这里有个很简单的小技巧，可以在LookAt方法后面加...
PBRT笔记(13)——光线传播1：表面反射
weixin_34138377的博客
03-20 740
采样反射函数 BxDF::Sample_f()方法根据与相应的散射函数相似的分布来选择方向。在8.2节中，该方法用于寻找来自完美镜面的反射和透射光线;在这里讲介绍实现其他类型的采样技术。 BxDF::Sample_f()在[0,1)范围内取得两个使用反演法取得的样本，其中这些样本是使用分层采样或者低偏差采样生成的，所以这些样本本身具有很好的分布性。 这个方法默认采用余弦加权的半球采样。这个样本分布...
PBRT_V2 总结记录 <15> Transform 和 Coordinate Spaces 和 Coordinate System Handedness
aa20274270的博客
10-12 378
Transform 类 class Transform { public: Transform Public Methods private: Transform Private Data }; 类的作用： （Transform 代表的就是一个矩阵，这个矩阵是 行为主的，也就是类似为OpenGL的矩阵计算方式） A transformation is represented by the...
Q108：浅析PBRT-V3的代码结构
图形跟班
05-24 1935
前续知识： Q106：Linux系统下安装编译PBRT-V3 Q107：Linux系统下GDB对PBRT-V3进行debug 108.1 理论介绍 咱这篇文章要讲的内容不是如下这些基类，当然这些绝对时系统的核心结构。 这篇文章的主要内容是：从.pbrt场景描述文件到render()循环前的这个过程。 PBRT中的场景描述文件相当于《Ray T
投影和环境相机模型（PBRT）
qq_41940565的博客
02-04 480
PBRT投影和环境相机模型
C++中使用opencv读取.exr文件
CAFE-BABE的博客
11-24 3459
因为最近用到了有些数据库，里面的深度图片是.exr后缀的，但是在使用opencv读取的时候，发现imread读取的数据始终都是空的，甚是纳闷，网上查询使用opencv读取exr文件的资料也大多是基于python的，但是我使用是c++，没啥帮助，于是自己研究了一下。 首先，写个简单的demo来读取.exr图片，以及查看当前的opencv支不支持exr格式的读取。注：默认编译的opencv是不支持的。 首先cpp文件： #include <iostream> #include <chr
PBRT-v2在windows下的配置与使用
traceorigin的专栏
12-14 4353
配置： 1）从官方网站下载PBRT软件包：http://www.pbrt.org/downloads.php，选择pbrt-v2-src.zip,for Windows。将压缩包解压到某一目录下，推荐解压到硬盘的根目录，例如D:\pbrt-v2 2）使用Microsoft Visual Studio 2008打开压缩包中的src/pbrt.vs2008/pbrt.sln，选择Deb
使用PBRT渲染图像训练Faster R-CNN进行无人机检测
通过使用PBRT渲染的图像对Faster R-CNN进行训练，模型在手动标注的无人机图像测试集上达到了80.69%的平均精度（AP）。这一结果表明，即使没有大量真实世界的标注数据，利用PBRT生成的数据也能有效地训练深度学习模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值