LensConfig Struct Reference

#include <SLGLOVRWorkaround.h>

Public Member Functions
float	DistortionFnScaleRadiusSquared (float rsq) const
SLVec3f	DistortionFnScaleRadiusSquaredChroma (float rsq) const
float	DistortionFn (float r) const
float	DistortionFnInverse (float r) const
float	DistortionFnInverseApprox (float r) const
void	SetUpInverseApprox ()
void	SetToIdentity ()

Public Attributes
DistortionEqnType	Eqn
float	K [NumCoefficients]
float	MaxR
float	MetersPerTanAngleAtCenter
float	ChromaticAberration [4]
float	InvK [NumCoefficients]
float	MaxInvR

Detailed Description

Definition at line 217 of file SLGLOVRWorkaround.h.

Member Function Documentation

DistortionFn()

float LensConfig::DistortionFn ( float  r ) const

inline

Definition at line 263 of file SLGLOVRWorkaround.h.

    {
        return r * DistortionFnScaleRadiusSquared(r * r);
    }

DistortionFnInverse()

float LensConfig::DistortionFnInverse ( float  r ) const

inline

Definition at line 269 of file SLGLOVRWorkaround.h.

    {
        assert((r <= 20.0f));
 
        float s, d;
        float delta = r * 0.25f;
 
        // Better to start guessing too low & take longer to converge than too high
        // and hit singularities. Empirically, r * 0.5f is too high in some cases.
        s = r * 0.25f;
        d = fabs(r - DistortionFn(s));
 
        for (int i = 0; i < 20; i++)
        {
            float sUp   = s + delta;
            float sDown = s - delta;
            float dUp   = fabs(r - DistortionFn(sUp));
            float dDown = fabs(r - DistortionFn(sDown));
 
            if (dUp < d)
            {
                s = sUp;
                d = dUp;
            }
            else if (dDown < d)
            {
                s = sDown;
                d = dDown;
            }
            else
            {
                delta *= 0.5f;
            }
        }
 
        return s;
    }

DistortionFnInverseApprox()

float LensConfig::DistortionFnInverseApprox ( float  r ) const

inline

Definition at line 308 of file SLGLOVRWorkaround.h.

    {
        float rsq   = r * r;
        float scale = 1.0f;
        switch (Eqn)
        {
            case Distortion_Poly4:
                // Deprecated
                assert(false);
                break;
            case Distortion_RecipPoly4:
                scale = 1.0f / (InvK[0] + rsq * (InvK[1] + rsq * (InvK[2] + rsq * InvK[3])));
                break;
            case Distortion_CatmullRom10:
            {
                // A Catmull-Rom spline through the values 1.0, K[1], K[2] ... K[9]
                // evenly spaced in R^2 from 0.0 to MaxR^2
                // K[0] controls the slope at radius=0.0, rather than the actual value.
                const int NumSegments = NumCoefficients;
                assert(NumSegments <= NumCoefficients);
                float scaledRsq = (float)(NumSegments - 1) * rsq / (MaxInvR * MaxInvR);
                scale           = EvalCatmullRom10Spline(InvK, scaledRsq);
            }
            break;
            default:
                assert(false);
                break;
        }
        return r * scale;
    }

DistortionFnScaleRadiusSquared()

float LensConfig::DistortionFnScaleRadiusSquared ( float  rsq ) const

inline

Definition at line 220 of file SLGLOVRWorkaround.h.

    {
        float scale = 1.0f;
        switch (Eqn)
        {
            case Distortion_Poly4:
                // This version is deprecated! Prefer one of the other two.
                scale = (K[0] + rsq * (K[1] + rsq * (K[2] + rsq * K[3])));
                break;
            case Distortion_RecipPoly4:
                scale = 1.0f / (K[0] + rsq * (K[1] + rsq * (K[2] + rsq * K[3])));
                break;
            case Distortion_CatmullRom10:
            {
                // A Catmull-Rom spline through the values 1.0, K[1], K[2] ... K[10]
                // evenly spaced in R^2 from 0.0 to MaxR^2
                // K[0] controls the slope at radius=0.0, rather than the actual value.
                const int NumSegments = NumCoefficients;
                assert(NumSegments <= NumCoefficients);
                float scaledRsq = (float)(NumSegments - 1) * rsq / (MaxR * MaxR);
                scale           = EvalCatmullRom10Spline(K, scaledRsq);
            }
            break;
            default:
                assert(false);
                break;
        }
        return scale;
    }

DistortionFnScaleRadiusSquaredChroma()

SLVec3f LensConfig::DistortionFnScaleRadiusSquaredChroma ( float  rsq ) const

inline

Definition at line 250 of file SLGLOVRWorkaround.h.

    {
        float   scale = DistortionFnScaleRadiusSquared(rsq);
        SLVec3f scaleRGB;
        scaleRGB.x = scale * (1.0f + ChromaticAberration[0] + rsq * ChromaticAberration[1]); // Red
        scaleRGB.y = scale;                                                                  // Green
        scaleRGB.z = scale * (1.0f + ChromaticAberration[2] + rsq * ChromaticAberration[3]); // Blue
        return scaleRGB;
    }

SetToIdentity()

void LensConfig::SetToIdentity ( )

inline

Definition at line 425 of file SLGLOVRWorkaround.h.

    {
        for (int i = 0; i < NumCoefficients; i++)
        {
            K[i]    = 0.0f;
            InvK[i] = 0.0f;
        }
        Eqn                       = Distortion_RecipPoly4;
        K[0]                      = 1.0f;
        InvK[0]                   = 1.0f;
        MaxR                      = 1.0f;
        MaxInvR                   = 1.0f;
        ChromaticAberration[0]    = 0.0f;
        ChromaticAberration[1]    = 0.0f;
        ChromaticAberration[2]    = 0.0f;
        ChromaticAberration[3]    = 0.0f;
        MetersPerTanAngleAtCenter = 0.05f;
    }

SetUpInverseApprox()

void LensConfig::SetUpInverseApprox ( )

inline

Definition at line 339 of file SLGLOVRWorkaround.h.

    {
        float maxR = MaxInvR;
 
        switch (Eqn)
        {
            case Distortion_Poly4:
                // Deprecated
                assert(false);
                break;
            case Distortion_RecipPoly4:
            {
 
                float sampleR[4];
                float sampleRSq[4];
                float sampleInv[4];
                float sampleFit[4];
 
                // Found heuristically...
                sampleR[0] = 0.0f;
                sampleR[1] = maxR * 0.4f;
                sampleR[2] = maxR * 0.8f;
                sampleR[3] = maxR * 1.5f;
                for (int i = 0; i < 4; i++)
                {
                    sampleRSq[i] = sampleR[i] * sampleR[i];
                    sampleInv[i] = DistortionFnInverse(sampleR[i]);
                    sampleFit[i] = sampleR[i] / sampleInv[i];
                }
                sampleFit[0] = 1.0f;
                FitCubicPolynomial(InvK, sampleRSq, sampleFit);
 
#if 0
                // Should be a nearly exact match on the chosen points.
                OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[0] ) - DistortionFnInverseApprox ( sampleR[0] ) ) / maxR < 0.0001f );
                OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[1] ) - DistortionFnInverseApprox ( sampleR[1] ) ) / maxR < 0.0001f );
                OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[2] ) - DistortionFnInverseApprox ( sampleR[2] ) ) / maxR < 0.0001f );
                OVR_ASSERT ( fabs ( DistortionFnInverse ( sampleR[3] ) - DistortionFnInverseApprox ( sampleR[3] ) ) / maxR < 0.0001f );
                // Should be a decent match on the rest of the range.
                const int maxCheck = 20;
                for ( int i = 0; i < maxCheck; i++ )
                {
                    float checkR = (float)i * maxR / (float)maxCheck;
                    float realInv = DistortionFnInverse       ( checkR );
                    float testInv = DistortionFnInverseApprox ( checkR );
                    float error = fabsf ( realInv - testInv ) / maxR;
                    OVR_ASSERT ( error < 0.1f );
                }
#endif
            }
            break;
            case Distortion_CatmullRom10:
            {
 
                const int NumSegments = NumCoefficients;
                assert(NumSegments <= NumCoefficients);
                for (int i = 1; i < NumSegments; i++)
                {
                    float scaledRsq = (float)i;
                    float rsq       = scaledRsq * MaxInvR * MaxInvR / (float)(NumSegments - 1);
                    float r         = sqrtf(rsq);
                    float inv       = DistortionFnInverse(r);
                    InvK[i]         = inv / r;
                    InvK[0]         = 1.0f; // TODO: fix this.
                }
 
#if 0
                const int maxCheck = 20;
                for ( int i = 0; i <= maxCheck; i++ )
                {
                    float checkR = (float)i * MaxInvR / (float)maxCheck;
                    float realInv = DistortionFnInverse       ( checkR );
                    float testInv = DistortionFnInverseApprox ( checkR );
                    float error = fabsf ( realInv - testInv ) / MaxR;
                    OVR_ASSERT ( error < 0.01f );
                }
#endif
            }
            break;
 
            default:
                break;
        }
    }

Member Data Documentation

ChromaticAberration

float LensConfig::ChromaticAberration[4]

Definition at line 455 of file SLGLOVRWorkaround.h.

Eqn

DistortionEqnType LensConfig::Eqn

Definition at line 444 of file SLGLOVRWorkaround.h.

InvK

float LensConfig::InvK[NumCoefficients]

Definition at line 457 of file SLGLOVRWorkaround.h.

K

float LensConfig::K[NumCoefficients]

Definition at line 445 of file SLGLOVRWorkaround.h.

MaxInvR

float LensConfig::MaxInvR

Definition at line 458 of file SLGLOVRWorkaround.h.

MaxR

float LensConfig::MaxR

Definition at line 446 of file SLGLOVRWorkaround.h.

MetersPerTanAngleAtCenter

float LensConfig::MetersPerTanAngleAtCenter

Definition at line 448 of file SLGLOVRWorkaround.h.

---

The documentation for this struct was generated from the following file:

• SLGLOVRWorkaround.h