---

Haar.cc

Go to the documentation of this file.

/*
        File:           Haar.cc

        Function:       Implementation of the Haar basis

        Author:         Andrew Willmott

        Notes:          
*/

#include "Haar.h"
#include "RadMethod.h"
#include "gcl/Draw.h"

#define DBG_COUT if (0) cerr

#define RAD_SAMPLE_ERROR

// --- HaarLink methods -------------------------------------------------------


Bool HaarLink::CalcTransport()
{
    if (gRadControl->quadLevel > 3)
        transport = From()->SampledFormFactor(8, To(), error);
    else
    {
        transport = From()->EstFormFactor(To());
        error = transport;
    }

    if (transport == 0.0 && error == 0.0)
        return(false);

    return(true);
}

Bool HaarLink::CalcVisibility(HRLink *parent, Bool reuse)
{
    if (parent && (reuse || !NeedVisibility(parent)))
        visibility = parent->visibility;
    else
        visibility = From()->Visibility(To());
    
    transport *= visibility;

    return(true);
}

Void HaarLink::Gather()
{
    To()->R += transport * From()->B;
}

GCLReal HaarLink::Error()
{
    return(error);
}

GCLReal HaarLink::BFAError()
{
    return(To()->area * error * 
        dot(kRadRGBToLum, To()->Reflectance() * From()->B));
}

Void HaarLink::Print(ostream &s)
{
    HRLink::Print(s);
    s << transport << ' ' << visibility << ' ';
}

Void HaarLink::DrawLink(Renderer &r, GCLReal left, GCLReal top,
                        GCLReal right, GCLReal bottom, GCLReal weight)
{
    r.SetColour(To()->Reflectance() * transport * visibility * weight);

    PaintRect(r, Coord(left, top), Coord(right, bottom));
}


// --- HaarElem methods -------------------------------------------------------


Colour HaarElem::lastB;

Void HaarElem::Add()
{
    B += R;
}

Void HaarElem::Push()
{
    Int i;
    
    for (i = 0; i < 4; i++)
        Child(i)->B = B;
}

Void HaarElem::Pull()
{
    Int     i;
    
    B = vl_0;
    for (i = 0; i < 4; i++)
        B += Child(i)->B;
    B /= 4.0;
}

Void HaarElem::ClearB()
{
    //  Save B for comparison to post push/pull B
    lastB = B;
    //  Initialise B to emittance of this patch.
    B = vl_0;
}

GCLReal HaarElem::Error()
{
    return(dot(kRadRGBToLum, B - lastB));
}

Void HaarElem::ClearR()
{
    R = vl_0;
}

Void HaarElem::CalcLeafRadiosity()
{
    B = Emittance() + Reflectance() * B;
}

Void HaarElem::Print(ostream &s)
{
    s << " + haar ";
    PrintRec(s);
}

Void HaarElem::PrintSelf(ostream &s)
{
    HRMeshElem::PrintSelf(s);
    s << B << ' ';
}

Void HaarElem::ParseSelf(istream &s)
{
    HRMeshElem::ParseSelf(s);
    s >> B;
}

Void HaarElem::SetParent(HierElem &itsParent)
{
    HierElem::SetParent(itsParent);

    B = ((HaarElem &) itsParent).B; 
}

Colour HaarElem::SampleLeaf(Coord c)
{

    if (gRadControl->gouraud)
    {
        Colour  c1, c2;

        c1 = Mix(VtxClr(0), VtxClr(3), c[0]); 
        c2 = Mix(VtxClr(1), VtxClr(2), c[0]); 
        return(Mix(c2, c1, c[1]));
    }
    else
        return(B);
}

Void HaarElem::EltSampleTransport(
        Int     numSamples,
        Point   p[],
        Vector  n[],
        Matd    &coeffs
    )
    // find coeffs s.t. dot(from->B, coeffs) = irradiance
    // at p, n.
{
    Int     i;

    for (i = 0; i < numSamples; i++)
        coeffs[i][0] = ApproxPatchFactor(p[i], n[i]);
    DBG_COUT << "haar: sample coeffs = " << coeffs << endl;
}

GCLReal HaarElem::EltCalcTransport(HRElem *from, Matd &coeffs)
{
    if (from == this)
    {
        // no self-reflection for haar...
        coeffs = vl_0;
        return(0.0);
    }

#ifndef RAD_SAMPLE_ERROR
    from->EltSampleTransport(1, &centre, &normal, coeffs);
    DBG_COUT << "haar: transport coeffs = " << coeffs << endl;
    return(coeffs[0][0]);
#else
    GCLReal     error;
    Point       p[16];
    Vector      n[16];
    static Matd t;
    Int         i, samples;

#ifdef RAD_SC
    // sample at 3 or 4 corners and centre.

    for (i = 0; i < Sides(); i++)
    {
        p[i] = Vertex(i);
        n[i] = normal;
    }
    p[i] = centre;
    n[i] = normal;
    samples = i + 1;
#else
    samples = 16;
    SetVisPoints(p);
    for (i = 0; i < 16; i++)
        n[i] = normal;
#endif
    t.SetSize(samples, from->NumCoeffs());

    from->EltSampleTransport(samples, p, n, t);

    // find (Linf) error in samples
    error = VecError(col(t, 0));
    // average samples to get coeffs...
    coeffs[0] = t[0];
    for (i = 1; i < t.Rows(); i++)
        coeffs[0] += t[i];
    coeffs[0] /= t.Rows();

    return(error);
#endif
}

Void HaarElem::AddIrradiance(const Colour &E, const Vector &m)
{
    GCLReal     temp;

    temp = dot(m, normal);
    if (temp > 0.0)
        R += temp * E;
}

Colour HaarElem::GetPower(const Vector &m)
{
    return(B * EltProjArea(m));
}

Void HaarElem::DistributeColours()
{
    SetColour(B);

    if (HasChildren())
    {
        Child(0)->DistributeColours();
        Child(1)->DistributeColours();
        Child(2)->DistributeColours();
        Child(3)->DistributeColours();
    }
}

Void HaarElem::DistributeColoursBest(ShadeInfo &shadeInfo)
{
    if (gRadControl->bestLevels == 0)
    {
        // for now we return. eventually would like to resample at vertices
        // same as the clusters. (only perhaps avoiding duplicate samples.)
        DistributeColours();
        return;
    }

    // Here we apply the leaf element irradiances to the leaf face clusters

    if (!links.IsEmpty())
        shadeInfo.linkStack.Push(&links);

    if (IsLeaf() && shadeInfo.level >= gRadControl->bestLevels)
    {
        Int         i, nlinks = 0;
        HRLinkIter  l;
            
        Point       centreOff, srcPt;
        Vector      r;
        GCLReal     dp, r2;
        Colour      E;

        // find face's normal, pos & area in WCS

        centreOff = centre;
        centreOff += 1e-6 * normal;
        colour = cBlack;

        // traverse all links, do final gather
        for (i = 0; i < shadeInfo.linkStack.NumItems(); i++)
            for (l.Begin(*shadeInfo.linkStack[i]); !l.AtEnd(); l.Inc())
            {
                HRElem *src = l.Data().from;

                nlinks++;               
                srcPt = src->EltCentre();
                r = srcPt - centre;
                dp = dot(r, normal);
                r2 = sqrlen(r);

                if (dp > 0 && r2 > 0)
                {
                    E = src->GetPower(-r);
                    E *= dp / (sqr(r2) * vl_pi + src->EltArea());

                    if (!gRadControl->bestVisPass)
                        E *= l.Data().visibility;
                    else
                    {
                        dp = l.Data().visibility;
                        if (dp == 0.0)
                            E = vl_0;
                        else if (dp < 1.0)  // dot(kRadRGBToLum, E) > 0.01
                        {
                            r /= sqrt(r2) * 1e6;
                            srcPt -= r;
                            if (gRadControl->radObject->
                                IntersectsWithRay(srcPt, centreOff))
                                    E = vl_0;
                            gRadControl->rays++;
                        }
                        else
                            E *= dp;
                    }
                    colour += E * Reflectance();
                }
            }

        colour += Emittance();
    }
    else
    {
        Bool amSubdividing = IsLeaf();

        if (amSubdividing)
        {
            shadeInfo.level++;

            flags.Set(hrIntNode);
            if (!HasChildren())
                Subdivide();
        }

        Child(0)->DistributeColoursBest(shadeInfo);
        Child(1)->DistributeColoursBest(shadeInfo);
        Child(2)->DistributeColoursBest(shadeInfo);
        Child(3)->DistributeColoursBest(shadeInfo);

        if (amSubdividing)
            shadeInfo.level--;
    }

    if (!links.IsEmpty())
        shadeInfo.linkStack.Pop();
}

---