स्पष्ट प्रकाश नमूनाकरण के साथ प्रगतिशील पथ अनुरेखण

पथ अनुरेखण में कई क्षेत्र हैं जिन्हें महत्व दिया जा सकता है। इसके अलावा, उन क्षेत्रों में से प्रत्येक भी कई महत्व के नमूने का उपयोग कर सकते हैं, पहले वीच और गुइबास के 1995 के पेपर में प्रस्तावित हैं । बेहतर ढंग से समझाने के लिए, आइए एक पीछे के पथ अनुरेखक को देखें:

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);
    SurfaceInteraction interaction;

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

        // The ray missed. Return the background color
        if (ray.GeomID == INVALID_GEOMETRY_ID) {
            color += throughput * m_scene->BackgroundColor;
            break;
        }

        // 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 emission
        if (light != nullptr) {
            color += throughput * light->Le();
        }

        interaction.Position = ray.Origin + ray.Direction * ray.TFar;
        interaction.Normal = normalize(m_scene->InterpolateNormal(ray.GeomID, ray.PrimID, ray.U, ray.V));
        interaction.OutputDirection = normalize(-ray.Direction);


        // Get the new ray direction
        // Choose the direction based on the bsdf        
        material->bsdf->Sample(interaction, sampler);
        float pdf = material->bsdf->Pdf(interaction);

        // Accumulate the weight
        throughput = throughput * material->bsdf->Eval(interaction) / pdf;

        // Shoot a new ray

        // Set the origin at the intersection point
        ray.Origin = interaction.Position;

        // Reset the other ray properties
        ray.Direction = interaction.InputDirection;
        ray.TNear = 0.001f;
        ray.TFar = infinity;


        // Russian Roulette
        if (bounces > 3) {
            float p = std::max(throughput.x, std::max(throughput.y, throughput.z));
            if (sampler->NextFloat() > p) {
                break;
            }

            throughput *= 1 / p;
        }
    }

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

अंग्रेजी में:

दृश्य के माध्यम से एक किरण को गोली मारो
जाँच करें कि क्या हमने कुछ मारा। यदि हम स्काईबॉक्स का रंग नहीं लौटाते और तोड़ते।
जाँच करें कि क्या हमने एक प्रकाश मारा। यदि हां, तो हम अपने रंग संचय के लिए प्रकाश उत्सर्जन को जोड़ते हैं
अगली किरण के लिए एक नई दिशा चुनें। हम बीआरडीएफ के आधार पर समान रूप से, या महत्व का नमूना कर सकते हैं
BRDF का मूल्यांकन करें और उसे संचित करें। मोंटे कार्लो एल्गोरिदम का पालन करने के लिए, हमें अपनी चुनी हुई दिशा के पीडीएफ को विभाजित करना होगा।
हमारी चुनी हुई दिशा के आधार पर एक नई किरण बनाएं और जहां हम अभी आए हैं
[वैकल्पिक] यह चुनने के लिए रूसी रूले का उपयोग करें कि क्या हमें किरण को समाप्त करना चाहिए
गोटो १

इस कोड के साथ, हम केवल रंग प्राप्त करते हैं यदि किरण अंततः एक प्रकाश को हिट करती है। इसके अलावा, यह समय-समय पर प्रकाश स्रोतों का समर्थन नहीं करता है, क्योंकि उनके पास कोई क्षेत्र नहीं है।

इसे ठीक करने के लिए, हम सीधे हर उछाल पर रोशनी का नमूना लेते हैं। हमें कुछ छोटे बदलाव करने होंगे:

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);
    SurfaceInteraction interaction;

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

        // The ray missed. Return the background color
        if (ray.GeomID == INVALID_GEOMETRY_ID) {
            color += throughput * m_scene->BackgroundColor;
            break;
        }

        // 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 this is the first bounce or if we just had a specular bounce,
        // we need to add the emmisive light
        if ((bounces == 0 || (interaction.SampledLobe & BSDFLobe::Specular) != 0) && light != nullptr) {
            color += throughput * light->Le();
        }

        interaction.Position = ray.Origin + ray.Direction * ray.TFar;
        interaction.Normal = normalize(m_scene->InterpolateNormal(ray.GeomID, ray.PrimID, ray.U, ray.V));
        interaction.OutputDirection = normalize(-ray.Direction);


        // Calculate the direct lighting
        color += throughput * SampleLights(sampler, interaction, material->bsdf, light);


        // Get the new ray direction
        // Choose the direction based on the bsdf        
        material->bsdf->Sample(interaction, sampler);
        float pdf = material->bsdf->Pdf(interaction);

        // Accumulate the weight
        throughput = throughput * material->bsdf->Eval(interaction) / pdf;

        // Shoot a new ray

        // Set the origin at the intersection point
        ray.Origin = interaction.Position;

        // Reset the other ray properties
        ray.Direction = interaction.InputDirection;
        ray.TNear = 0.001f;
        ray.TFar = infinity;


        // Russian Roulette
        if (bounces > 3) {
            float p = std::max(throughput.x, std::max(throughput.y, throughput.z));
            if (sampler->NextFloat() > p) {
                break;
            }

            throughput *= 1 / p;
        }
    }

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

सबसे पहले, हम "कलर + = थ्रूपुट * सैंपललाइट्स (...)" जोड़ते हैं। मैं एक सा में नमूना () के बारे में विस्तार से जाऊँगा। लेकिन, अनिवार्य रूप से, यह सभी रोशनी से गुजरता है, और बीएसडीएफ द्वारा देखे गए रंग में अपना योगदान देता है।

यह बहुत अच्छा है, लेकिन हमें इसे सही करने के लिए एक और बदलाव करने की आवश्यकता है; विशेष रूप से, जब हम एक प्रकाश को मारते हैं तो क्या होता है। पुराने कोड में, हमने प्रकाश के उत्सर्जन को रंग संचय में जोड़ा। लेकिन अब हम सीधे हर उछाल पर प्रकाश डालते हैं, इसलिए यदि हमने प्रकाश के उत्सर्जन को जोड़ा, तो हम "डबल डिप" करेंगे। इसलिए, सही बात यह है ... कुछ भी नहीं; हम प्रकाश के उत्सर्जन को जमा करना छोड़ देते हैं।

हालांकि, दो कोने मामले हैं:

पहली किरण
बिल्कुल सट्टा उछाल (उर्फ दर्पण)

यदि पहली किरण प्रकाश से टकराती है, तो आपको प्रकाश का उत्सर्जन सीधे देखना चाहिए। इसलिए यदि हम इसे छोड़ देते हैं, तो सभी रोशनी काले रंग की दिखाई देंगी, भले ही उनके चारों ओर की सतहों को जलाया जाए।

जब आप पूरी तरह से स्पेक्युलर सतहों से टकराते हैं तो आप सीधे प्रकाश का नमूना नहीं ले सकते, क्योंकि एक इनपुट किरण का केवल एक आउटपुट होता है। ठीक है, तकनीकी रूप से, हम कर सकता है, तो इनपुट रे एक प्रकाश हिट करने के लिए जा रहा है की जाँच करें, लेकिन कोई मतलब नहीं है, मुख्य पथ अनुरेखण पाश वैसे भी करने जा रहा है। इसलिए, यदि हम एक स्पेक्युलर सतह से टकराकर प्रकाश को मारते हैं, तो हमें रंग जमा करने की आवश्यकता होती है। यदि हम नहीं करते हैं, तो रोशनी दर्पण में काली होगी।

अब, चलो नमूना () में तल्लीन करें:

float3 SampleLights(UniformSampler *sampler, SurfaceInteraction interaction, BSDF *bsdf, Light *hitLight) const {
    std::size_t numLights = m_scene->NumLights();

    float3 L(0.0f);
    for (uint i = 0; i < numLights; ++i) {
        Light *light = &m_scene->Lights[i];

        // Don't let a light contribute light to itself
        if (light == hitLight) {
            continue;
        }

        L = L + EstimateDirect(light, sampler, interaction, bsdf);
    }

    return L;
}

अंग्रेजी में:

सभी लाइटों के माध्यम से लूप
अगर हम इसे मारते हैं तो प्रकाश को छोड़ दें
- डबल डुबकी मत करो
सभी लाइटों से सीधी लाइटिंग संचित करें
प्रत्यक्ष प्रकाश वापस लौटें

अंत में, () बस ) का मूल्यांकन कर $BSDF(p, \omega_{\text{i}}, \omega_{\text{o}}) L_{\text{i}}(p, \omega_{\text{i}})$

समयनिष्ठ प्रकाश स्रोतों के लिए, यह सरल है:

float3 EstimateDirect(Light *light, UniformSampler *sampler, SurfaceInteraction &interaction, BSDF *bsdf) const {
    // Only sample if the BRDF is non-specular 
    if ((bsdf->SupportedLobes & ~BSDFLobe::Specular) != 0) {
        return float3(0.0f);
    }

    interaction.InputDirection = normalize(light->Origin - interaction.Position);
    return bsdf->Eval(interaction) * light->Li;
}

हालाँकि, यदि हम रोशनी के लिए क्षेत्र चाहते हैं, तो हमें पहले प्रकाश पर एक बिंदु का नमूना लेना होगा। इसलिए, पूर्ण परिभाषा है:

float3 EstimateDirect(Light *light, UniformSampler *sampler, SurfaceInteraction &interaction, BSDF *bsdf) const {
    float3 directLighting = float3(0.0f);

    // Only sample if the BRDF is non-specular 
    if ((bsdf->SupportedLobes & ~BSDFLobe::Specular) != 0) {
        float pdf;
        float3 Li = light->SampleLi(sampler, m_scene, interaction, &pdf);

        // Make sure the pdf isn't zero and the radiance isn't black
        if (pdf != 0.0f && !all(Li)) {
            directLighting += bsdf->Eval(interaction) * Li / pdf;
        }
    }

    return directLighting;
}

हम प्रकाश को लागू कर सकते हैं-> हालांकि हम चाहते हैं नमूना; हम समान रूप से, या महत्व के नमूने का चयन कर सकते हैं। या तो मामले में, हम बिंदु को चुनने की पीडीएफ द्वारा रेडियोसिटी को विभाजित करते हैं। फिर से, मोंटे कार्लो की आवश्यकताओं को पूरा करने के लिए।

यदि BRDF अत्यधिक दृश्य निर्भर है, तो प्रकाश पर यादृच्छिक बिंदु के बजाय BRDF पर आधारित बिंदु चुनना बेहतर हो सकता है। लेकिन हम कैसे चुनते हैं? नमूना प्रकाश पर आधारित है, या BRDF पर आधारित है?

क्यों न दोनों? एकाधिक महत्व का नमूना दर्ज करें। संक्षेप में, हम कई बार, अलग-अलग सैंपलिंग तकनीकों का उपयोग करते हुए, फिर उनके pdfs के आधार पर वज़न का उपयोग करके उन्हें एक साथ औसत करें। कोड में यह है: $BSDF(p, \omega_{\text{i}}, \omega_{\text{o}}) L_{\text{i}}(p, \omega_{\text{i}})$

float3 EstimateDirect(Light *light, UniformSampler *sampler, SurfaceInteraction &interaction, BSDF *bsdf) const {
    float3 directLighting = float3(0.0f);
    float3 f;
    float lightPdf, scatteringPdf;


    // Sample lighting with multiple importance sampling
    // Only sample if the BRDF is non-specular 
    if ((bsdf->SupportedLobes & ~BSDFLobe::Specular) != 0) {
        float3 Li = light->SampleLi(sampler, m_scene, interaction, &lightPdf);

        // Make sure the pdf isn't zero and the radiance isn't black
        if (lightPdf != 0.0f && !all(Li)) {
            // Calculate the brdf value
            f = bsdf->Eval(interaction);
            scatteringPdf = bsdf->Pdf(interaction);

            if (scatteringPdf != 0.0f && !all(f)) {
                float weight = PowerHeuristic(1, lightPdf, 1, scatteringPdf);
                directLighting += f * Li * weight / lightPdf;
            }
        }
    }


    // Sample brdf with multiple importance sampling
    bsdf->Sample(interaction, sampler);
    f = bsdf->Eval(interaction);
    scatteringPdf = bsdf->Pdf(interaction);
    if (scatteringPdf != 0.0f && !all(f)) {
        lightPdf = light->PdfLi(m_scene, interaction);
        if (lightPdf == 0.0f) {
            // We didn't hit anything, so ignore the brdf sample
            return directLighting;
        }

        float weight = PowerHeuristic(1, scatteringPdf, 1, lightPdf);
        float3 Li = light->Le();
        directLighting += f * Li * weight / scatteringPdf;
    }

    return directLighting;
}

अंग्रेजी में:

सबसे पहले, हम प्रकाश का नमूना लेते हैं
- यह इंटरेक्शन को अद्यतन करता है। InputDirection
- प्रकाश के लिए हमें Li देता है
- और प्रकाश पर उस बिंदु को चुनने का पीडीएफ
जांचें कि पीडीएफ वैध है और चमक गैर शून्य है
नमूना इनपुटडायरेक्शन का उपयोग करके बीएसडीएफ का मूल्यांकन करें
नमूना इनपुटडायरेक्शन दिए गए बीएसडीएफ के लिए पीडीएफ की गणना करें
- अनिवार्य रूप से, यह नमूना कितना संभावना है, अगर हम प्रकाश के बजाय बीएसडीएफ का उपयोग करके नमूना कर रहे थे
प्रकाश पीडीएफ और बीएसडीएफ पीडीएफ का उपयोग करके, वजन की गणना करें
- वेट और गुइबास ने वजन की गणना करने के लिए कुछ तरीकों को परिभाषित किया है। प्रायोगिक तौर पर, उन्होंने अधिकांश मामलों के लिए सबसे अच्छा काम करने के लिए 2 की शक्ति के साथ शक्ति को प्रेरित किया। मैं आपको अधिक जानकारी के लिए कागज पर संदर्भित करता हूं। कार्यान्वयन नीचे है
प्रत्यक्ष प्रकाश गणना के साथ वजन गुणा करें और प्रकाश पीडीएफ द्वारा विभाजित करें। (मोंटे कार्लो के लिए) और प्रत्यक्ष प्रकाश संचय में जोड़ें।
फिर, हम BRDF का नमूना लेते हैं
- यह इंटरेक्शन को अद्यतन करता है। InputDirection
BRDF का मूल्यांकन करें
BRDF के आधार पर इस दिशा को चुनने के लिए पीडीएफ प्राप्त करें
सैंपल इनपुटडायरेक्शन को देखते हुए, प्रकाश पीडीएफ की गणना करें
- यह पहले का दर्पण है। इस दिशा में कितनी संभावना है, अगर हम प्रकाश का नमूना लें
यदि lightPdf == 0.0f है, तो किरण प्रकाश से चूक गई है, इसलिए प्रकाश नमूना से सीधे प्रकाश वापस लौटाएं।
अन्यथा, वजन की गणना करें, और संचय के लिए बीएसडीएफ प्रत्यक्ष प्रकाश जोड़ें
अंत में, संचित प्रत्यक्ष प्रकाश लौटाएं

।

inline float PowerHeuristic(uint numf, float fPdf, uint numg, float gPdf) {
    float f = numf * fPdf;
    float g = numg * gPdf;

    return (f * f) / (f * f + g * g);
}

इन कार्यों में आप कई प्रकार के अनुकूलन / सुधार कर सकते हैं, लेकिन मैंने उन्हें समझने के लिए आसान बनाने के लिए प्रयास किया है। यदि आप चाहें, तो मैं इनमें से कुछ सुधारों को साझा कर सकता हूं।

केवल एक प्रकाश नमूना

नमूना लाइट () में हम सभी रोशनी के माध्यम से लूप करते हैं, और अपना योगदान प्राप्त करते हैं। कम संख्या में रोशनी के लिए, यह ठीक है, लेकिन सैकड़ों या हजारों रोशनी के लिए, यह महंगा हो जाता है। सौभाग्य से, हम इस तथ्य का फायदा उठा सकते हैं कि मोंटे कार्लो एकीकरण एक विशाल औसत है। उदाहरण:

चलो परिभाषित करते हैं

h (x) = f (x) + g (x)

$h(x) = f(x) + g(x)$

वर्तमान में, हम अनुमान लगा रहे हैं : $h(x)$

h (x) = \frac{1}{N} \sum_{i = 1}^{N} f (x_{i}) + g (x_{i})

$h(x) = \frac{1}{N} \sum_{i=1}^N f(x_i) + g(x_i)$

लेकिन, और दोनों की गणना करना महंगा है, इसलिए इसके बजाय हम करते हैं: $f(x)$ $g(x)$

h (x) = \frac{1}{N} \sum_{i = 1}^{N} \frac{r (ζ, x)}{p d f}

$h(x) = \frac{1}{N} \sum_{i=1}^N \frac{r(\zeta, x)}{pdf}$

जहाँ एक समान यादृच्छिक चर है, और को इस प्रकार परिभाषित किया गया है: $\zeta$ $r(\zeta, x)$

r (ζ, x) = {\begin{cases} f (x), & 0.0 \leq ζ < 0.5 \\ g (x), & 0.5 \leq ζ < 1.0 \end{cases}

$r(\zeta, x) = \begin{cases} f(x), & 0.0 \leq \zeta \lt 0.5 \\ g(x), & 0.5 \leq \zeta \lt 1.0 \end{cases}$

इस स्थिति में क्योंकि पीडीएफ को 1 से एकीकृत होना चाहिए, और इसमें से चुनने के लिए 2 कार्य हैं। $pdf = \frac{1}{2}$

अंग्रेजी में:

मूल्यांकन करने के लिए रैंडम या तो या । $f(x)$ $g(x)$
परिणाम को से विभाजित करें (क्योंकि दो आइटम हैं) $\frac{1}{2}$
औसत

जैसे ही N बड़ा होता है, अनुमान सही समाधान में परिवर्तित हो जाएगा।

हम प्रकाश के नमूने के लिए इसी सिद्धांत को लागू कर सकते हैं। हर प्रकाश के नमूने के बजाय, हम बेतरतीब ढंग से एक को उठाते हैं, और परिणाम को रोशनी की संख्या से गुणा करते हैं (यह भिन्नात्मक पीडीएफ द्वारा विभाजित के समान है):

float3 SampleOneLight(UniformSampler *sampler, SurfaceInteraction interaction, BSDF *bsdf, Light *hitLight) const {
    std::size_t numLights = m_scene->NumLights();

    // Return black if there are no lights
    // And don't let a light contribute light to itself
    // Aka, if we hit a light
    // This is the special case where there is only 1 light
    if (numLights == 0 || numLights == 1 && hitLight != nullptr) {
        return float3(0.0f);
    }

    // Don't let a light contribute light to itself
    // Choose another one
    Light *light;
    do {
        light = m_scene->RandomOneLight(sampler);
    } while (light == hitLight);

    return numLights * EstimateDirect(light, sampler, interaction, bsdf);
}

इस कोड में, सभी रोशनी को उठाया जाने की समान संभावना है। हालांकि, हम नमूना महत्व कर सकते हैं, अगर हम पसंद करते हैं। उदाहरण के लिए, हम बड़ी रोशनी को उठाया जा सकता है, या हिट सतह के करीब रोशनी दे सकते हैं। आपको बस परिणाम पीडीएफ से विभाजित करना होगा, जो अब । $\frac{1}{\text{numLights}}$

एकाधिक महत्व "नई रे" दिशा का नमूना

वर्तमान कोड बीएसडीएफ पर आधारित "न्यू रे" दिशा के नमूने को ही महत्व देता है। क्या होगा अगर हम रोशनी के स्थान के आधार पर भी नमूना महत्व देना चाहते हैं?

ऊपर हमने जो कुछ सीखा, उससे लेते हुए, एक विधि दो "नई" किरणों को शूट करना और प्रत्येक को उनके pdfs के आधार पर वजन करना होगा। हालांकि, यह दोनों कम्प्यूटेशनल रूप से महंगा है, और पुनरावृत्ति के बिना लागू करना कठिन है।

इसे दूर करने के लिए, हम उन्हीं सिद्धांतों को लागू कर सकते हैं जिन्हें हमने केवल एक प्रकाश के नमूने द्वारा सीखा है। यही है, बेतरतीब ढंग से एक नमूना चुनें, और इसे चुनने के पीडीएफ से विभाजित करें।

// Get the new ray direction

// Randomly (uniform) choose whether to sample based on the BSDF or the Lights
float p = sampler->NextFloat();

Light *light = m_scene->RandomLight();

if (p < 0.5f) {
    // Choose the direction based on the bsdf 
    material->bsdf->Sample(interaction, sampler);
    float bsdfPdf = material->bsdf->Pdf(interaction);

    float lightPdf = light->PdfLi(m_scene, interaction);
    float weight = PowerHeuristic(1, bsdfPdf, 1, lightPdf);

    // Accumulate the throughput
    throughput = throughput * weight * material->bsdf->Eval(interaction) / bsdfPdf;

} else {
    // Choose the direction based on a light
    float lightPdf;
    light->SampleLi(sampler, m_scene, interaction, &lightPdf);

    float bsdfPdf = material->bsdf->Pdf(interaction);
    float weight = PowerHeuristic(1, lightPdf, 1, bsdfPdf);

    // Accumulate the throughput
    throughput = throughput * weight * material->bsdf->Eval(interaction) / lightPdf;
}

उस सभी ने कहा, क्या हम वास्तव में प्रकाश के आधार पर "न्यू रे" दिशा को महत्व देना चाहते हैं ? के लिए प्रत्यक्ष प्रकाश, रेडियोसिटी दोनों सतह के BSDF, और प्रकाश की दिशा से प्रभावित है। लेकिन अप्रत्यक्ष प्रकाश व्यवस्था के लिए, रेडियोसिटी को लगभग विशेष रूप से बीएसडीएफ द्वारा परिभाषित सतह से पहले मारा जाता है। इसलिए, प्रकाश महत्व के नमूने को जोड़ने से हमें कुछ भी नहीं मिलता है।

इसलिए, बीएसडीएफ के साथ "नई दिशा" को केवल महत्व देना आम है, लेकिन प्रत्यक्ष प्रकाश व्यवस्था के लिए कई महत्व वाले नमूने लागू करें।

— RichieSams
स्रोत

स्पष्ट उत्तर के लिए धन्यवाद! मैं समझता हूं कि अगर हम स्पष्ट प्रकाश नमूने के बिना एक पथ अनुरेखक का उपयोग करते हैं, तो हम कभी भी एक बिंदु प्रकाश स्रोत से नहीं टकराएंगे। इसलिए, हम मूल रूप से इसके योगदान को जोड़ सकते हैं। दूसरी ओर, अगर हम एक क्षेत्र प्रकाश स्रोत का नमूना लेते हैं, तो हमें यह सुनिश्चित करना होगा कि हम इसे दोहरे प्रकाश से बचने के लिए अप्रत्यक्ष प्रकाश के साथ फिर से न

— टकराएं

बिल्कुल सही! क्या कोई हिस्सा है जिस पर आपको स्पष्टीकरण की आवश्यकता है? या पर्याप्त विस्तार नहीं है?

— रिचीम्स

इसके अलावा, कई महत्वपूर्ण नमूने केवल प्रत्यक्ष प्रकाश गणना के लिए उपयोग किए जाते हैं? शायद मैं चूक गया लेकिन मुझे इसका दूसरा उदाहरण नहीं दिखाई दिया। अगर मैं अपने पथ अनुरेखक में प्रति किरण बस एक किरण को गोली मारता हूं, तो ऐसा लगता है कि मैं इसे अप्रत्यक्ष प्रकाश गणना के लिए नहीं कर सकता।

— मुस्तफा इस्क

आप महत्व नमूने का उपयोग कहीं भी कई महत्व नमूनाकरण लागू किया जा सकता है। कई महत्व के नमूने की शक्ति यह है कि हम कई नमूना तकनीकों के लाभों को जोड़ सकते हैं। उदाहरण के लिए, कुछ मामलों में, बीएसडीएफ के नमूने की तुलना में हल्के महत्व का नमूना बेहतर होगा। अन्य मामलों में, इसके विपरीत। MIS दोनों दुनिया के सर्वश्रेष्ठ को मिलाएगा। हालांकि, यदि बीएसडीएफ नमूना 100% बेहतर होगा, तो एमआईएस की जटिलता को जोड़ने का कोई कारण नहीं है। मैंने इस बिंदु पर विस्तार करने के लिए उत्तर में कुछ खंड जोड़े

— रिचीम्स

ऐसा लगता है कि हमने आने वाले चमक स्रोतों को प्रत्यक्ष और अप्रत्यक्ष रूप से दो भागों में अलग कर दिया है। हम प्रत्यक्ष भाग के लिए स्पष्ट रूप से रोशनी का नमूना लेते हैं और इस हिस्से का नमूना लेते समय, यह महत्वपूर्ण है कि रोशनी के साथ-साथ बीएसडीएफ के नमूने का भी महत्व है। अप्रत्यक्ष भाग के लिए, हालांकि, हमें इस बारे में कोई जानकारी नहीं है कि कौन सी दिशा संभवतः हमें उच्च मूलांक मान दे सकती है क्योंकि यह स्वयं समस्या है जिसे हम हल करना चाहते हैं। हालांकि, हम कह सकते हैं कि कोसाइन टर्म और बीएसडीएफ के अनुसार कौन सी दिशा अधिक योगदान दे सकती है। यह मैं समझता हूं। अगर मैं गलत हूं तो मुझे सुधारो और अपने भयानक जवाब के लिए धन्यवाद।

— मुस्तफा इश्क