Apa Pentingnya Pengambilan Sampel?


33

Apa itu sampling penting? Setiap artikel yang saya baca tentang itu menyebutkan 'PDF' apa itu juga?

Dari apa yang saya kumpulkan, pentingnya sampling adalah teknik untuk hanya sampel area di belahan bumi yang lebih penting daripada yang lain. Jadi, idealnya, saya harus mencicipi sinar ke arah sumber cahaya untuk mengurangi kebisingan dan meningkatkan kecepatan. Juga, beberapa BRDF di sudut penggembalaan memiliki sedikit perbedaan dalam perhitungan sehingga menggunakan sampel penting untuk menghindari itu bagus?

Jika saya menerapkan sampel penting untuk Cook-Torrance BRDF, bagaimana saya bisa melakukan ini?


Ini adalah tautan bacaan yang baik yang menjelaskan apa itu PDF. TL; DR a PDF adalah fungsi yang menggambarkan probabilitas angka acak (continuous alias floating point). Menghasilkan angka acak dari PDF tertentu bisa jadi menantang dan ada beberapa teknik untuk melakukannya. Ini berbicara tentang salah satunya. Artikel setelah ini berbicara tentang cara lain. blog.demofox.org/2017/08/05/…
Alan Wolfe

Jawaban:


51

Jawaban singkat:

Importance sampling adalah metode untuk mengurangi varians dalam Integrasi Monte Carlo dengan memilih penduga yang mendekati bentuk fungsi sebenarnya.

PDF adalah singkatan untuk Probability Density Function . A pdf(x) memberikan kemungkinan sampel acak yang dihasilkan adalah x .

Jawaban panjang:

Untuk memulai, mari kita tinjau apa Integrasi Monte Carlo itu, dan seperti apa secara matematis.

Integrasi Monte Carlo adalah teknik untuk memperkirakan nilai integral. Ini biasanya digunakan ketika tidak ada solusi bentuk tertutup untuk integral. Ini terlihat seperti ini:

f(x)dx1Ni=1Nf(xi)pdf(xi)

Dalam bahasa Inggris, ini mengatakan bahwa Anda dapat memperkirakan integral dengan rata-rata sampel acak berturut-turut dari fungsi. Ketika N menjadi besar, pendekatannya semakin dekat dan lebih dekat ke solusi. pdf(xi) merupakan fungsi kepadatan probabilitas masing-masing sampel acak.

Mari kita lakukan contoh: Hitung nilai integral I .

I=02πe?xsin?(x)dx

Mari kita gunakan Integrasi Monte Carlo:

I1Ni=1Ne?xsin?(xi)pdf(xi)

Program python sederhana untuk menghitung ini adalah:

import random
import math

N = 200000
TwoPi = 2.0 * math.pi

sum = 0.0

for i in range(N):
    x = random.uniform(0, TwoPi)

    fx = math.exp(-x) * math.sin(x)
    pdf = 1 / (TwoPi - 0.0)

    sum += fx / pdf

I = (1 / N) * sum
print(I)

Jika kami menjalankan program, kami mendapatkan I=0.4986941

Menggunakan pemisahan oleh bagian, kita bisa mendapatkan solusi yang tepat:

I=12(1?e?2π)=0.4990663

Anda akan melihat bahwa Solusi Monte Carlo tidak sepenuhnya benar. Ini karena ini adalah perkiraan. Yang mengatakan, ketika N pergi ke tak terhingga, estimasi harus semakin dekat dan lebih dekat ke jawaban yang benar. Sudah di N=2000 beberapa berjalan hampir identik dengan jawaban yang benar.

Catatan tentang PDF: Dalam contoh sederhana ini, kami selalu mengambil sampel acak yang seragam. Sampel acak yang seragam berarti setiap sampel memiliki probabilitas yang sama untuk dipilih. Kami sampel dalam kisaran [0,2π] jadi, pdf(x)=1/(2π?0)

Pengambilan sampel penting bekerja dengan cara pengambilan sampel yang tidak seragam. Sebagai gantinya kami mencoba untuk memilih lebih banyak sampel yang berkontribusi banyak pada hasil (penting), dan lebih sedikit sampel yang hanya berkontribusi sedikit pada hasil (kurang penting). Karena itulah namanya, pentingnya pengambilan sampel.

ffPerbandingan pengambilan sampel yang baik vs pengambilan sampel yang buruk

Salah satu contoh pengambilan sampel penting di Path Tracing adalah bagaimana memilih arah sinar setelah menyentuh permukaan. Jika permukaannya tidak spekular sempurna (mis. Cermin atau kaca), sinar yang keluar bisa di mana saja di belahan bumi.

Sinar yang keluar bisa ke mana saja di belahan bumi

Kita bisa secara seragam mencicipi belahan bumi untuk menghasilkan sinar baru. Namun, kita dapat mengeksploitasi fakta bahwa persamaan rendering memiliki faktor cosinus di dalamnya:

Lo(p,ωo)=Le(p,ωo)+Ωf(p,ωi,ωo)Li(p,ωi)|cos?θi|dωi

cos?(x)

Untuk mengatasi ini, kami menggunakan sampel penting. Jika kita menghasilkan sinar berdasarkan belahan tertimbang kosinus, kita memastikan bahwa lebih banyak sinar dihasilkan jauh di atas cakrawala, dan lebih sedikit di dekat cakrawala. Ini akan menurunkan varians dan mengurangi noise.

Dalam kasus Anda, Anda menetapkan bahwa Anda akan menggunakan BRDF berbasis mikrofaset Cook-Torrance. Bentuk umum adalah:

f(p,ωi,ωo)=F(ωi,h)G(ωi,ωo,h)D(h)4cos?(θi)cos?(θo)

where

F(ωi,h)=Fresnel functionG(ωi,ωo,h)=Geometry Masking and Shadowing functionD(h)=Normal Distribution Function

The blog "A Graphic's Guy's Note" has an excellent write up on how to sample Cook-Torrance BRDFs. I will refer you to his blog post. That said, I will try to create a brief overview below:

The NDF is generally the dominant portion of the Cook-Torrance BRDF, so if we are going to importance sample, the we should sample based on the NDF.

Cook-Torrance doesn't specify a specific NDF to use; we are free to choose whichever one suits our fancy. That said, there are a few popular NDFs:

  • GGX
  • Beckmann
  • Blinn

Each NDF has it's own formula, thus each must be sampled differently. I am only going to show the final sampling function for each. If you would like to see how the formula is derived, see the blog post.

GGX is defined as:

DGGX(m)=α2π((α2?1)cos2?(θ)+1)2

To sample the spherical coordinates angle θ, we can use the formula:

θ=arccos?(α2ξ1(α2?1)+1)

where ξ is a uniform random variable.

We assume that the NDF is isotropic, so we can sample ? uniformly:

?=ξ2

Beckmann is defined as:

DBeckmann(m)=1πα2cos4?(θ)e?tan2?(θ)α2

Which can be sampled with:

θ=arccos?(11=α2ln?(1?ξ1))?=ξ2

Lastly, Blinn is defined as:

DBlinn(m)=α+22π(cos?(θ))α

Which can be sampled with:

θ=arccos?(1ξ1α+1)?=ξ2

Putting it in Practice

Let's look at a basic backwards path tracer:

void RenderPixel(uint x, uint y, UniformSampler *sampler) {
    Ray ray = m_scene->Camera.CalculateRayFromPixel(x, y, sampler);

    float3 color(0.0f);
    float3 throughput(1.0f);

    // Bounce the ray around the scene
    for (uint bounces = 0; bounces < 10; ++bounces) {
        m_scene->Intersect(ray);

        // The ray missed. Return the background color
        if (ray.geomID == RTC_INVALID_GEOMETRY_ID) {
            color += throughput * float3(0.846f, 0.933f, 0.949f);
            break;
        }

        // We hit an object

        // Fetch the material
        Material *material = m_scene->GetMaterial(ray.geomID);
        // The object might be emissive. If so, it will have a corresponding light
        // Otherwise, GetLight will return nullptr
        Light *light = m_scene->GetLight(ray.geomID);

        // If we hit a light, add the emmisive light
        if (light != nullptr) {
            color += throughput * light->Le();
        }

        float3 normal = normalize(ray.Ng);
        float3 wo = normalize(-ray.dir);
        float3 surfacePos = ray.org + ray.dir * ray.tfar;

        // Get the new ray direction
        // Choose the direction based on the material
        float3 wi = material->Sample(wo, normal, sampler);
        float pdf = material->Pdf(wi, normal);

        // Accumulate the brdf attenuation
        throughput = throughput * material->Eval(wi, wo, normal) / pdf;


        // Shoot a new ray

        // Set the origin at the intersection point
        ray.org = surfacePos;

        // Reset the other ray properties
        ray.dir = wi;
        ray.tnear = 0.001f;
        ray.tfar = embree::inf;
        ray.geomID = RTC_INVALID_GEOMETRY_ID;
        ray.primID = RTC_INVALID_GEOMETRY_ID;
        ray.instID = RTC_INVALID_GEOMETRY_ID;
        ray.mask = 0xFFFFFFFF;
        ray.time = 0.0f;
    }

    m_scene->Camera.FrameBuffer.SplatPixel(x, y, color);
}

IE. we bounce around the scene, accumulating color and light attenuation as we go. At each bounce, we have to choose a new direction for the ray. As mentioned above, we could uniformly sample the hemisphere to generate the new ray. However, the code is smarter; it importance samples the new direction based on the BRDF. (Note: This is the input direction, because we are a backwards path tracer)

// Get the new ray direction
// Choose the direction based on the material
float3 wi = material->Sample(wo, normal, sampler);
float pdf = material->Pdf(wi, normal);

Which could be implemented as:

void LambertBRDF::Sample(float3 outputDirection, float3 normal, UniformSampler *sampler) {
    float rand = sampler->NextFloat();
    float r = std::sqrtf(rand);
    float theta = sampler->NextFloat() * 2.0f * M_PI;

    float x = r * std::cosf(theta);
    float y = r * std::sinf(theta);

    // Project z up to the unit hemisphere
    float z = std::sqrtf(1.0f - x * x - y * y);

    return normalize(TransformToWorld(x, y, z, normal));
}

float3a TransformToWorld(float x, float y, float z, float3a &normal) {
    // Find an axis that is not parallel to normal
    float3a majorAxis;
    if (abs(normal.x) < 0.57735026919f /* 1 / sqrt(3) */) {
        majorAxis = float3a(1, 0, 0);
    } else if (abs(normal.y) < 0.57735026919f /* 1 / sqrt(3) */) {
        majorAxis = float3a(0, 1, 0);
    } else {
        majorAxis = float3a(0, 0, 1);
    }

    // Use majorAxis to create a coordinate system relative to world space
    float3a u = normalize(cross(normal, majorAxis));
    float3a v = cross(normal, u);
    float3a w = normal;


    // Transform from local coordinates to world coordinates
    return u * x +
           v * y +
           w * z;
}

float LambertBRDF::Pdf(float3 inputDirection, float3 normal) {
    return dot(inputDirection, normal) * M_1_PI;
}

After we sample the inputDirection ('wi' in the code), we use that to calculate the value of the BRDF. And then we divide by the pdf as per the Monte Carlo formula:

// Accumulate the brdf attenuation
throughput = throughput * material->Eval(wi, wo, normal) / pdf;

Where Eval() is just the BRDF function itself (Lambert, Blinn-Phong, Cook-Torrance, etc.):

float3 LambertBRDF::Eval(float3 inputDirection, float3 outputDirection, float3 normal) const override {
    return m_albedo * M_1_PI * dot(inputDirection, normal);
}

Nice answer. The OP also asked about Cook-Torrance importance sampling which this answer doesn't touch upon.
PeteUK

6
I updated the answer to add a section about Cook-Torrance
RichieSams

For example GGX, to sample spherical coordinates angle cos(θ) we use the importance sampled formula to calculate the angle and use that in GGX as usual right? Or does the formula replace GGX entirely?
Arjan Singh

3
I added a section to help answer your questions. But, in short, your first method is correct. You use the sampling formula to generate a direction, then you use that new direction in the normal GGX formula and to get the pdf for the Monte Carlo formula.
RichieSams

For GGX how would I calculate/sample wi? I understand how to sample the spherical coordinates angle θ but for the actual direction vector how is that done?
Arjan Singh

11

If you have a 1D function f(x) and you want to integrate this function from say 0 to 1, one way to perform this integration is by taking N random samples in range [0, 1], evaluate f(x) for each sample and calculate the average of the samples. However, this "naive" Monte Carlo integration is said to "converge slowly", i.e. you need a large number of samples to get close to the ground truth, particularly if the function has high frequencies.

With importance sampling, instead of taking N random samples in [0, 1] range, you take more samples in the "important" regions of f(x) that contribute most to the final result. However, because you bias sampling towards the important regions of the function, these samples must be weighted less to counter the bias, which is where the PDF (probability density function) comes along. PDF tells the probability of a sample at given position and is used to calculate weighted average of the samples by dividing the each sample with the PDF value at each sample position.

With Cook-Torrance importance sampling the common practice is to distribute samples based on the normal distribution function NDF. If NDF is already normalized, it can serve directly as PDF, which is convenient since it cancels the term out from the BRDF evaluation. Only thing you need to do then is to distribute sample positions based on PDF and evaluate BRDF without the NDF term, i.e.

f=FGπ(n?ωi)(n?ωo)
And calculate average of the sample results multiplied by the solid angle of the domain you integrate over (e.g. 2π for hemisphere).

For NDF you need to calculate Cumulative Distribution Function of the PDF to convert uniformly distributed sample position to PDF weighted sample position. For isotropic NDF this simplifies to 1D function because of the symmetry of the function. For more details about the CDF derivation you can check this old GPU Gems article.

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.
Judi bola