Surface Integrators. Digital Image Synthesis Yung-Yu Chuang 12/20/2007

Transcription

1 Surface Integrators Dgtal Image Synthess Yung-Yu Chuang 12/20/2007 wth sldes by Peter Shrley, Pat Hanrahan, Henrk Jensen, Maro Costa Sousa and Torsten Moller

2 Drect lghtng va Monte Carlo ntegraton dffuse

3 Drect lghtng va Monte Carlo ntegraton parameterzaton over hemsphere parameterzaton over surface have to add vsblty

4 Drect lghtng va Monte Carlo ntegraton take one sample accordng to a densty functon let s take

5 Drect lghtng va Monte Carlo ntegraton 1 sample/pxel 100 samples/pxel Lghts szes matter more than shapes. Nosy because x could be on the back cos vares

6 Nose reducton choose better densty functon It s equvalent to unformly samplng over the cone cap n the last lecture. cosθ = (1 ξ + 1) ξ1 cos θ max φ = 2πξ 2 cosα max

7 Drect lghtng from many lumnares Gven a par, use t to select lght and generate new par for samplng that lght. α could be constant for proportonal to power

8 Man renderng loop vod Scene::Render() { Sample *sample = new Sample(surfaceIntegrator, volumeintegrator, ths);... whle (sampler->getnextsample(sample)) { RayDfferental ray; float rw = camera->generateray(*sample, &ray); <Generate ray dfferentals for camera ray> float alpha; Spectrum Ls = 0.f; f (rw > 0.f) Ls = rw * L(ray, sample, &alpha);... camera->flm->addsample(*sample,ray,ls,alpha);... }... camera->flm->wrteimage(); }

9 Scene::L Spectrum Scene::L(RayDfferental &ray, Sample *sample, float *alpha) { Spectrum Lo=surfaceIntegrator->L( ); Spectrum T=volumeIntegrator->Transmttance( ); Spectrum Lv=volumeIntegrator->L( ); return T * Lo + Lv; } Lv L o T

10 Surface ntegrators Responsble for evaluatng the ntegral equaton core/transport.* ntegrator/* Whtted, drectlghtng, path, bdrectonal, rradancecache, photonmap g, exphotonmap class COREDLL Integrator { Spectrum L(Scene *scene, RayDfferental &ray, Sample *sample, float *alpha); vod Proprocess(Scene *scene) vod RequestSamples(Sample*, Scene*) }; class SurfaceIntegrator : publc Integrator

11 Surface ntegrators vod Preprocess(const Scene *scene) Called after scene has been ntalzed; do scenedependent computaton such as photon shootng for photon mappng. vod RequestSamples(Sample *sample, const Scene *scene) Sample s allocated once n Render(). There, sample s constructor wll call ntegrator s RequestSamples to allocate approprate space. Sample::Sample(SurfaceIntegrator *surf, VolumeIntegrator *vol, const Scene *scene) { // calculate requred number of samples // accordng to ntegraton strategy surf->requestsamples(ths, scene);...

12 Drect lghtng o o e o o d p L p f p L p L ω θ ω ω ω ω ω cos ), ( ),, ( ), ( ), ( Ω + = d o o e o o d p L p f p L p L ω θ ω ω ω ω ω cos ), ( ),, ( ), ( ), ( Ω + = Renderng equaton If we only consder drect lghtng, we can replace L by L d. smplest form of equaton somewhat easy to solve (but a gross approxmaton) knd of what we do n Whtted ray tracng Not too bad snce most energy comes from drect lghts

13 Drect lghtng Monte Carlo samplng to solve Ω f ( p, ω, ω ) L ( p, ω ) cosθ o d Samplng strategy A: sample only one lght pck up one lght as the representatve for all lghts dstrbute N samples over that lght Use multple mportance samplng for f and L d N 1 f ( p, ω o, ω j ) Ld ( p, ω j ) N 1 p( ω ) j= Scale the result by the number of lghts N L j dω cosθ j E [ f + g] Randomly pck f or g and then sample, multply the result by 2

14 Drect lghtng Samplng strategy B: sample all lghts do A for each lght sum the results smarter way would be to sample lghts accordng to ther power N L j= 1 Ω f ( p, ω, ω ) L dω o d ( j) ( p, ω ) cosθ E [ f + g] sample f or g separately and then sum them together

15 DrectLghtng enum LghtStrategy { SAMPLE_ALL_UNIFORM, SAMPLE_ONE_UNIFORM, SAMPLE_ONE_WEIGHTED }; two possble strateges; f there are many mage samples for a pxel (e.g. due to depth of feld), we prefer only samplng one lght at a tme. On the other hand, f there are few mage samples, we prefer samplng all lghts at once. class DrectLghtng : publc SurfaceIntegrator { publc: maxmal depth DrectLghtng(LghtStrategy ls, nt md);... }

16 RequestSamples Dfferent types of lghts requre dfferent number of samples, usually 2D samples. Samplng BRDF requres 2D samples. Selecton of BRDF components requres 1D samples. n1d n2d flled n by ntegrators sample oned twod allocate together to avod cache mss mem ntegrator bsdfcomponent lghtsample bsdfsample

17 DrectLghtng::RequestSamples vod RequestSamples(Sample *sample, const Scene *scene) { f (strategy == SAMPLE_ALL_UNIFORM) { u_nt nlghts = scene->lghts.sze(); lghtsampleoffset = new nt[nlghts]; bsdfsampleoffset = new nt[nlghts]; bsdfcomponentoffset = new nt[nlghts]; for (u_nt = 0; < nlghts; ++) { const Lght *lght = scene->lghts[]; nt lghtsamples gves sampler a chance to adjust to an approprate value = scene->sampler->roundsze(lght->nsamples); lghtsampleoffset[] = sample->add2d(lghtsamples); bsdfsampleoffset[] = sample->add2d(lghtsamples); bsdfcomponentoffset[] = sample->add1d(lghtsamples); } lghtnumoffset = -1; }

18 DrectLghtng::RequestSamples else { lghtsampleoffset = new nt[1]; bsdfsampleoffset = new nt[1]; bsdfcomponentoffset = new nt[1]; lghtsampleoffset[0] = sample->add2d(1); bsdfsampleoffset[0] = sample->add2d(1); bsdfcomponentoffset[0] = sample->add1d(1); } } lghtnumoffset = sample->add1d(1); whch lght to sample

19 DrectLghtng::L Spectrum DrectLghtng::L(Scene *scene, RayDfferental &ray, Sample *sample, float *alpha) { Intersecton sect; Spectrum L(0.); f (scene->intersect(ray, &sect)) { // Evaluate BSDF at ht pont BSDF *bsdf = sect.getbsdf(ray); Vector wo = -ray.d; const Pont &p = bsdf->dgshadng.p; const Normal &n = bsdf->dgshadng.nn; <Compute emtted lght; see next slde> } else { // handle ray wth no ntersecton } return L; }

20 DrectLghtng::L L o( p, o) = Le ( p, ωo) + Ω ω f ( p, ω, ω ) L ( p, ω ) cosθ o d dω L += sect.le(wo); f (scene->lghts.sze() > 0) { swtch (strategy) { case SAMPLE_ALL_UNIFORM: L += UnformSampleAllLghts(scene, p, n, wo, bsdf, sample, lghtsampleoffset, bsdfsampleoffset, bsdfcomponentoffset); break; case SAMPLE_ONE_UNIFORM: L += UnformSampleOneLght(scene, p, n, wo, bsdf, sample, lghtsampleoffset[0], lghtnumoffset, bsdfsampleoffset[0], bsdfcomponentoffset[0]); break;

21 DrectLghtng::L case SAMPLE_ONE_WEIGHTED: sample accordng to power L += WeghtedSampleOneLght(scene, p, n, wo, bsdf, sample, lghtsampleoffset[0], lghtnumoffset, bsdfsampleoffset[0], bsdfcomponentoffset[0], avgy, avgysample, cdf, overallavgy); break; } } f (raydepth++ < maxdepth) { // add specular reflected and transmtted contrbutons } Ths part s essentally the same as Whtted ntegrator. The man dfference between Whtted and DrectLghtng s the way they sample lghts. Whtted uses sample_l to take one sample for each lght. DrectLghtng uses multple Importance samplng to sample both lghts and BRDFs.

22 Whtted::L... // Add contrbuton of each lght source Vector w; for ( = 0; < scene->lghts.sze(); ++) { VsbltyTester vsblty; Spectrum L = scene->lghts[]-> Sample_L(p, &w, &vsblty); f (L.Black()) contnue; Spectrum f = bsdf->f(wo, w); f (!f.black() && vsblty.unoccluded(scene)) L += f * L * AbsDot(w, n) * vsblty.transmttance(scene); }...

23 UnformSampleAllLghts Spectrum UnformSampleAllLghts(...) { Spectrum L(0.); for (u_nt =0;<scene->lghts.sze();++) { Lght *lght = scene->lghts[]; nt nsamples = (sample && lghtsampleoffset)? sample->n2d[lghtsampleoffset[]] : 1; Spectrum Ld(0.); for (nt j = 0; j < nsamples; ++j) Ld += EstmateDrect(...); } L += Ld / nsamples; } return L; compute contrbuton for one sample for one lght f ( p, ω, ω ) L o j d ( p, ω ) cosθ p( ω ) j j j

24 UnformSampleOneLght Spectrum UnformSampleOneLght (...) { nt nlghts = nt(scene->lghts.sze()); nt lghtnum; f (lghtnumoffset!= -1) lghtnum = Floor2Int(sample->oneD[lghtNumOffset][0]*nLghts); else lghtnum = Floor2Int(RandomFloat() * nlghts); lghtnum = mn(lghtnum, nlghts-1); Lght *lght = scene->lghts[lghtnum]; return (float)nlghts * EstmateDrect(...); }

25 Multple mportance samplng = = + f n g j j g g j j g n f f f Y p Y w Y g Y f n X p X w X g X f n 1 1 ) ( ) ( ) ( ) ( 1 ) ( ) ( ) ( ) ( 1 ( ) ( ) = s s s x p n x p n x w β β ) ( ) ( ) (

26 EstmateDrect Spectrum EstmateDrect(Scene *scene, Lght *lght, Pont &p, Normal &n, Vector &wo, BSDF *bsdf, Sample *sample, nt lghtsamp, nt bsdfsamp, nt bsdfcomponent, u_nt samplenum) { f ( p, ω, ω ) L ( p, ω ) cosθ p( ω ) Spectrum Ld(0.); j float ls1, ls2, bs1, bs2, bcs; f (lghtsamp!= -1 && bsdfsamp!= -1 && samplenum < sample->n2d[lghtsamp] && samplenum < sample->n2d[bsdfsamp]) { ls1 = sample->twod[lghtsamp][2*samplenum]; ls2 = sample->twod[lghtsamp][2*samplenum+1]; bs1 = sample->twod[bsdfsamp][2*samplenum]; bs2 = sample->twod[bsdfsamp][2*samplenum+1]; bcs = sample->oned[bsdfcomponent][samplenum]; } else { ls1 = RandomFloat(); ls2 = RandomFloat();... } o j d j j

27 Sample lght wth MIS Spectrum L = lght->sample_l(p, n, ls1, ls2, &w, &lghtpdf, &vsblty); f (lghtpdf > 0. &&!L.Black()) { Spectrum f = bsdf->f(wo, w); f (!f.black() && vsblty.unoccluded(scene)) { L *= vsblty.transmttance(scene); f (lght->isdeltalght()) Ld += f * L * AbsDot(w, n) / lghtpdf; else { bsdfpdf = bsdf->pdf(wo, w); float weght = PowerHeurstc(1,lghtPdf,1,bsdfPdf); Ld += f * L * AbsDot(w, n) * weght / lghtpdf; } } } f ( p, ω, ω ) L o j d ( p, ω ) cosθ j p( ω ) j j w L ( ω ) j

28 Sample BRDF wth MIS f (!lght->isdeltalght()) { Only for non-delta lght and BSDF BxDFType flags = BxDFType(BSDF_ALL & ~BSDF_SPECULAR); Spectrum f = bsdf->sample_f(wo, &w, bs1, bs2, bcs, &bsdfpdf, flags); f (!f.black() && bsdfpdf > 0.) { lghtpdf = lght->pdf(p, n, w); f (lghtpdf > 0.) { // Add lght contrbuton from BSDF samplng float weght = PowerHeurstc(1,bsdfPdf,1,lghtPdf); Spectrum L(0.f); RayDfferental ray(p, w); f (scene->intersect(ray, &lghtisect)) { f (lghtisect.prmtve->getarealght() == lght) L = lghtisect.le(-w); } else L = lght->le(ray); for nfnte area lght f (!L.Black()) { L *= scene->transmttance(ray); Ld += f * L * AbsDot(w, n) * weght / bsdfpdf; } } }

29 Drect lghtng

30 The lght transport equaton The goal of ntegrator s to numercally solve the lght transport equaton, governng the equlbrum dstrbuton of radance n a scene.

31 The lght transport equaton

32 Analytc soluton to the LTE In general, t s mpossble to fnd an analytc soluton to the LTE because of complex BRDF, arbtrary scene geometry and ntrcate vsblty. For a extremely smple scene, e.g. nsde a unformly emttng Lambertan sphere, t s however possble. Ths s useful for debuggng. Radance should be the same for all ponts L = Le + cπl

33 Analytc soluton to the LTE L = Le + cπl L = L + ρ L = = L L e e e + + ρ ρ hh hh hh ( L ( L e e + + ρ ρ hh hh L) ( L e +... = = 0 L e ρ hh L L e = ρ hh 1 1 ρ hh

34 Surface form of the LTE

35 Surface form of the LTE These two forms are equvalent, but they represent two dfferent ways of approachng lght transport.

36 Surface form of the LTE

37 Surface form of the LTE

38 Surface form of the LTE

39 Delta dstrbuton

40 Partton the ntegrand

41 Partton the ntegrand

42 Partton the ntegrand

43 Renderng operators

44 Solvng the renderng equaton

45 Successve approxmaton

46 Successve approxmaton

47 Lght Transport Notaton (Hekbert 1990) Regular expresson denotng sequence of events along a lght path alphabet: {L,E,S,D,G} L a lght source (emtter) E the eye S specular reflecton/transmsson D dffuse reflecton/transmsson G glossy reflecton/transmsson operators: (k) + one or more of k (k) * zero or more of k (teraton) (k k ) a k or a k event

48 Lght Transport Notaton: Examples LSD a path startng at a lght, havng one specular reflecton and endng at a dffuse reflecton D L S

49 Lght Transport Notaton: Examples L(S D) + DE a path startng at a lght, havng one or more dffuse or specular reflectons, then a fnal dffuse reflecton toward the eye E D L S

50 Lght Transport Notaton: Examples L(S D) + DE a path startng at a lght, havng one or more dffuse or specular reflectons, then a fnal dffuse reflecton toward the eye S D E L D S

51

52

53 Renderng algorthms Ray castng: E(D G)L Whtted: E[S*](D G)L Kajya: E[(D G S) + (D G)]L Goral: ED*L

54 The renderng equaton

55 The renderng equaton

56 The radosty equaton

57 Radosty formulate the basc radosty equaton: B m = E m + ρ m N n=1 B n F mn B m = radosty = total energy leavng surface m (energy/unt area/unt tme) E m = energy emtted from surface m (energy/unt area/unt tme) ρ m = reflectvty, fracton of ncdent lght reflected back nto envronment F mn = form factor, fracton of energy leavng surface n that lands on surface m (A m = area of surface m)

58 Brng all the B s on one sde of the equaton ths leads to ths equaton system: E m = B m ρ m B n F mn m = N N NN N N N N N N N E E E B B B F F F F F F F F F M M M O M M ρ ρ ρ ρ ρ ρ ρ ρ ρ Radosty E B S = o

59 Path tracng Proposed by Kajya n hs classc SIGGRAPH 1986 paper, renderng equaton, as the soluton for Incrementally generates path of scatterng events startng from the camera and endng at lght sources n the scene. Two questons to answer How to do t n fnte tme? How to generate one or more paths to compute

60 Infnte sum In general, the longer the path, the less the mpact. Use Russan Roulette after a fnte number of bounces Always compute the frst few terms Stop after that wth probablty q

61 Infnte sum Take ths dea further and nstead randomly consder termnatng evaluaton of the sum at each term wth probablty q

62 Path generaton (frst tral) Frst, pck up surface n the scene randomly and unformly Then, pck up a pont on ths surface randomly and unformly wth probablty Overall probablty of pckng a random surface pont n the scene: = j j A A p A 1 = = j j j j A A A A A p p 1 1 ) (

63 Path generaton (frst tral) Ths s repeated for each pont on the path. Last pont should be sampled on lght sources only. If we know characterstcs about the scene (such as whch objects are contrbutng most ndrect lghtng to the scene), we can sample more smartly. Problems: Hgh varance: only few ponts are mutually vsble,.e. many of the paths yeld zero. Incorrect ntegral: for delta dstrbutons, we rarely fnd the rght path drecton

64 Incremental path generaton For pathp = p0 p1... p j p j p At each p j, fnd p j+1 accordng to BSDF At p -1, fnd p by multple mportance samplng of BSDF and L Ths algorthm dstrbutes samples accordng to sold angle nstead of area. So, the dstrbuton p A needs to be adjusted p A ( p ) = p ω p p + 1 cosθ 2

65 Incremental path generaton Monte Carlo estmator p 1 Implementaton re-uses path for new path Ths ntroduces correlaton, but speed makes up for t. p

66 Path tracng

67 Drect lghtng

68 Path tracng 8 samples per pxel

69 Path tracng 1024 samples per pxel

70 Bdrectonal path tracng Compose one path p from two paths p 1 p 2 p started at the camera p 0 and q j q j-1 q 1 started at the lght source q 0 p Modfcaton for effcency: p Use all paths whose lengths rangng from 2 to +j = 1 p2 p, q jq j q 1 Helpful for the stuatons n whch lghts are dffcult to reach and caustcs

71 Bdrectonal path tracng

72 Nose reducton/removal More samples (slow convergence) Better samplng (stratfed, mportance etc.) Flterng Cachng and nterpolaton

73 Based approaches By ntroducng bas (makng smoothness assumptons), based methods produce mages wthout hgh-frequency nose Unlke unbased methods, errors may not be reduced by addng samples n based methods On contrast, when there s lttle error n the result of an unbased method, we are confdent that t s close to the rght answer Three based approaches Flterng Irradance cachng Photon mappng

74 The world s more dffuse!

75 Flterng Nose s hgh frequency Methods: Smple flters Ansotropc flters Energy preservng flters Problems wth flterng: everythng s fltered (blurred)

76 Path tracng (10 paths/pxel)

77 3x3 lowpass flter

78 3x3 medan flter

79 Cachng technques Irradance cachng: compute rradance at selected ponts and nterpolate Photon mappng: trace photons from the lghts and store them n a photon map, that can be used durng renderng

80 Drect llumnaton

81 Global llumnaton

82 Indrect rradance Indrect llumnaton tends to be low frequency

83 Irradance cachng Introduced by Greg Ward 1988 Implemented n Radance renderer Contrbutons from ndrect lghtng often vary smoothly cache and nterpolate results

84 Irradance cachng Compute ndrect lghtng at sparse set of samples Interpolate neghborng values from ths set of samples Issues How s the ndrect lghtng represented How to come up wth such a sparse set of samples? How to store these samples? When and how to nterpolate?

85 Set of samples Indrect lghtng s computed on demand, store rradance n a spatal data structure. If there s no good nearby samples, then compute a new rradance sample Irradance (radance s drecton dependent, expensve to store) If the surface s Lambertan, H d p L p E ω θ ω = 2 cos ), ( ) ( ) ( cos ), ( cos ), ( ),, ( ), ( 2 2 p E d p L d p L p f p L H H o o o ρ ω θ ω ρ ω θ ω ω ω ω = = =

86 Set of samples For dffuse scenes, rradance alone s enough nformaton for accurate computaton For nearly dffuse surfaces (such as Oren-Nayar or a glossy surface wth a very wde specular lobe), we can vew rradance cachng makes the followng approxmaton ( )( ) ( ) ) ( ) ( cos ), ( ),, ( ), ( p E d p L d p f p L o hd H H o o o ω ρ ω θ ω ω ω ω ω drectonal reflectance

87 Set of samples Not a good approxmaton for specular surfaces specular Whtted ntegrator Dffuse rradance cachng Interpolate from known ponts Cosne-weghted Path tracng sample ponts E( p) = L ( p, ω ) cosθ 2 H dω 1 L = ( p, ω j ) cosθ j E( p) N j p( ω j ) π E ( p) = L ( p, ω j ) N j p( ω) = cosθ π

88 Storng samples {E,p,n,d} d

89 Interpolatng from neghbors Skp samples Normals are too dfferent Too far away In front Weght (ad hoc) w = 1 d d max 1 ' N N 2 Fnal rradance estmate s smply the weghted sum E = w E w

90 IrradanceCache class IrradanceCache : publc SurfaceIntegrator {... float maxerror; how frequently rradance samples are computed or nterpolated nt nsamples; how many rays for rradance samples nt maxspeculardepth, maxindrectdepth; mutable nt speculardepth; current depth for specular }

91 IrradanceCache::L L += sect.le(wo); L += UnformSampleAllLghts(scene, p, n, wo,...); f (speculardepth++ < maxspeculardepth) { <Trace rays for specular reflecton and refracton> } --speculardepth; // Estmate ndrect lghtng wth rradance cache... BxDFType flags = BxDFType(BSDF_REFLECTION BSDF_DIFFUSE BSDF_GLOSSY); L+=IndrectLo(p, ng, wo, bsdf, flags, sample, scene); flags = BxDFType(BSDF_TRANSMISSION BSDF_DIFFUSE BSDF_GLOSSY); L+=IndrectLo(p, -ng, wo, bsdf, flags, sample,scene);

92 IrradanceCache::IndrectLo f (!InterpolateIrradance(scene, p, n, &E)) {... // Compute rradance at current pont for (nt = 0; < nsamples; ++) { <Path tracng to compute radances along ray for rradance sample> E += L; float dst = r.maxt * r.d.length(); // max dstance suminvdsts += 1.f / dst; } E *= M_PI / float(nsamples);... // Add computed rradance value to cache octree->add(irradancesample(e,p,n,nsamples/suminvdsts), sampleextent); } return.5f * bsdf->rho(wo, flags) * E;

93 Octree Constructed at Preprocess() vod IrradanceCache::Preprocess(const Scene *scene) { BBox wb = scene->worldbound(); Vector delta =.01f * (wb.pmax - wb.pmn); wb.pmn -= delta; wb.pmax += delta; octree=new Octree<IrradanceSample,IrradProcess>(wb); } struct IrradanceSample { Spectrum E; Normal n; Pont p; float maxdst; };

94 InterpolateIrradance Bool InterpolateIrradance(const Scene *scene, const Pont &p, const Normal &n, Spectrum *E) { f (!octree) return false; IrradProcess proc(n, maxerror); octree->lookup(p, proc); Traverse the octree; for each node where the query pont s nsde, call a method of proc to process for each rradacne sample. } f (!proc.successful()) return false; *E = proc.getirradance(); return true;

95 IrradProcess vod IrradProcess::operator()(const Pont &p, const IrradanceSample &sample) { // Skp f surface normals are too dfferent f (Dot(n, sample.n) < 0.01f) return; // Skp f t's too far from the sample pont float d2 = DstanceSquared(p, sample.p); f (d2 > sample.maxdst * sample.maxdst) return; // Skp f t's n front of pont beng shaded Normal navg = sample.n + n; f (Dot(p - sample.p, navg) < -.01f) return; // Compute estmate error and possbly use sample float err=sqrtf(d2)/(sample.maxdst*dot(n,sample.n)); f (err < 1.) { float wt = (1.f - err) * (1.f - err); } } E += wt * sample.e; sumwt += wt; w = 1 d d max 1 ' N N 2

96 Comparson wth same lmted tme Irradance cachng Blotch artfacts Path tracng Hgh-frequency noses

97 Irradance cachng Irradance cachng Irradance sample postons

98 Photon mappng It can handle both dffuse and glossy reflecton; specular reflecton s handled by recursve ray tracng Two-step partcle tracng algorthm Photon tracng Smulate the transport of ndvdual photons Photons emtted from source Photons deposted on surfaces Photons reflected from surfaces to surfaces Renderng Collect photons for renderng

99 Photon tracng Preprocess: cast rays from lght sources

100 Photon tracng Preprocess: cast rays from lght sources Store photons (poston + lght power + ncomng drecton)

101 Photon map Effcently store photons for fast access Use herarchcal spatal structure (kd-tree)

102 Renderng (fnal gatherng) Cast prmary rays; for the secondary rays, reconstruct rradance usng the k closest stored photon

103 Renderng (wthout fnal gather) o o e o o d p L p f p L p L ω θ ω ω ω ω ω cos ), ( ),, ( ), ( ), ( Ω + =

104 Renderng (wth fnal gather)

105 Photon mappng results photon map renderng

106 Photon mappng - caustcs Specal photon map for specular reflecton and refracton

107 Caustcs Path tracng: 1,000 paths/pxel Photon mappng

108 PhotonIntegrator class PhotonIntegrator : publc SurfaceIntegrator { nt ncaustcphotons,nindrectphotons,ndrectphotons; nt nlookup; number of photons for nterpolaton (50~100) nt speculardepth, maxspeculardepth; float maxdstsquared; search dstance; too large, waste tme; too small, not enough samples bool drectwthphotons, fnalgather; nt gathersamples; } Left: 100K photons 50 photons n radance estmate Rght: 500K photons 500 photons n radance estmate

109 Photon map Kd-tree s used to store photons, decoupled from the scene geometry

110 Photon shootng Implemented n Preprocess method Three types of photons (caustc, drect, ndrect) struct Photon { Pont p; Spectrum alpha; Vector w; }; w p α

111 Photon shootng Use Halton sequence snce number of samples s unknown beforehand, startng from a sample L lght wth energy e ( p0, ω0). Store photons for nonspecular p( p0, ω0) surfaces.

112 Photon shootng vod PhotonIntegrator::Preprocess(const Scene *scene) { vector<photon> caustcphotons; vector<photon> drectphotons; vector<photon> ndrectphotons; whle (!caustcdone!drectdone!ndrectdone) { ++nshot; <trace a photon path and store contrbuton> } }

113 Photon shootng Spectrum alpha = lght->sample_l(scene, u[0], u[1], u[2], u[3], &photonray, &pdf); alpha /= pdf * lghtpdf; Whle (scene->intersect(photonray, &photonisect)) { alpha *= scene->transmttance(photonray); <record photon dependng on type> <sample next drecton> Spectrum fr = photonbsdf->sample_f(wo, &w, u1, u2, u3, &pdf, BSDF_ALL, &flags); alpha*=fr*absdot(w, photonbsdf->dgshadng.nn)/ pdf; photonray = RayDfferental(photonIsect.dg.p, w); f (nintersectons > 3) { f (RandomFloat() >.5f) break; alpha /=.5f; } }

114 Renderng Partton the ntegrand ( ) = Δ Δ cos ), ( ), ( ), ( ),, ( cos ), ( ),, ( cos ), ( ),, (,,, S c d o S o S o d p L p L p L p f d p L p f d p L p f ω θ ω ω ω ω ω ω θ ω ω ω ω θ ω ω ω

115 Renderng L += sect.le(wo); // Compute drect lghtng for photon map ntegrator f (drectwthphotons) L += LPhoton(drectMap,...); else L += UnformSampleAllLghts(...); // Compute ndrect lghtng for photon map ntegrator L += LPhoton(caustcMap,...); f (fnalgather) { <Do one-bounce fnal gather for photon map> } else L += LPhoton(ndrectMap,...); // Compute specular reflecton and refracton

116 Fnal gather for (nt = 0; < gathersamples; ++) { <compute radance for a random BSDF-sampled drecton for fnal gather ray> } L += L/float(gatherSamples);

117 Fnal gather BSDF *gatherbsdf = gatherisect.getbsdf(bounceray); Vector bouncewo = -bounceray.d; Spectrum Lndr = LPhoton(drectMap, ndrectpaths, nlookup, gatherbsdf, gatherisect, bouncewo, maxdstsquared) + LPhoton(ndrectMap, nindrectpaths, nlookup, gatherbsdf, gatherisect, bouncewo, maxdstsquared) + LPhoton(caustcMap, ncaustcpaths, nlookup, gatherbsdf, gatherisect, bouncewo,maxdstsquared); Lndr *= scene->transmttance(bounceray); L += fr * Lndr * AbsDot(w, n) / pdf;

118 Renderng 50,000 drect photons shadow rays are traced for drect lghtng

119 Renderng 500,000 drect photons caustcs

120 Photon mappng Drect llumnaton Photon mappng

121 Photon mappng + fnal gatherng Photon mappng +fnal gatherng Photon mappng

122 Photon nterpolaton LPhoton() fnds the nlookup closest photons and uses them to compute the radance at the pont. A kd-tree s used to store photons. To mantan the nlookup closest photons effcently durng search, a heap s used. For nterpolaton, a statstcal technque, densty estmaton, s used. Densty estmaton constructs a PDF from a set of gven samples, for example, hstogram.

123 Kernel method pˆ( x) = 1 Nh N = 1 k x x h wndow wdth where - k(x)dx = 1 h too wde too smooth h too narrow too bumpy k( t) = (1 2t ) / 5 t < 0 otherwse 5 h=0.1

124 Generalzed nth nearest-neghbor estmate float scale=1.f/(float(npaths)*maxdstsquared* M_PI); ) ( ) ( 1 ) ˆ( 1 = = N n n x d x x k x Nd x p dstance to nth nearest neghbor ω o < = otherwse 0 1 ) ( 1 x x k π 2D constant kernel

125 LPhoton f (bsdf->numcomponents(bxdftype(bsdf_reflection BSDF_TRANSMISSION BSDF_GLOSSY)) > 0) { // extant radance from photons for glossy surface for (nt = 0; < nfound; ++) { BxDFType flag=dot(nf, photons[].photon->w)> 0.f? BSDF_ALL_REFLECTION : BSDF_ALL_TRANSMISSION; L += bsdf->f(wo, photons[].photon->w, flag) * (scale * photons[].photon->alpha); }} else { // extant radance from photons for dffuse surface Spectrum Lr(0.), Lt(0.); for (nt = 0; < nfound; ++) f (Dot(Nf, photons[].photon->w) > 0.f) Lr += photons[].photon->alpha; else Lt += photons[].photon->alpha; L+=(scale*INV_PI)*(Lr*bsdf->rho(wo,BSDF_ALL_REFLECTION) +Lt*bsdf->rho(wo, BSDF_ALL_TRANSMISSION)); }

126 Results