VCRA-SZCZERBACKI-PointBasedRendering/ssAdditional.cpp

#include "ssAdditional.hpp"

using namespace SS;

//==============================================================
//==============================================================

//maximum absolute row sum norm
float SS::norm_inf( const Matrix3x3 &m )
{
        float n = 0.0f;
        for(int i=0;i<3;i++)
        {
                float nn = fabs(m[i][0]) + fabs(m[i][1]) + fabs(m[i][2]); 
                if( nn > n ) n = nn;
        }
        return n;
}

//==============================================================
//==============================================================

//maximum absolute column sum norm
float SS::norm_1( const Matrix3x3 &m )
{
        float n = 0.0f;
        for(int i=0;i<3;i++)
        {
                float nn = fabs(m[0][i]) + fabs(m[1][i]) + fabs(m[2][i]); 
                if( nn > n ) n = nn;
        }
        return n;
}

//==============================================================
//==============================================================

// random vector generation
Vector3 SS::randInBox( )
{
        return Vector3(randMinusHalfHalf( ), randMinusHalfHalf( ), randMinusHalfHalf( ));
}

//==============================================================
//==============================================================

Vector3 SS::randInBox( float edgeLength )
{
        return randInBox() * edgeLength * 0.5f;
}

//==============================================================
//==============================================================

Vector3 SS::randOnSphere()
{
        //distribution is uniform when random vectors inside a unit sphere are normalized
        Vector3 t;
        float d;
        do
        {
                t.x = randMinusHalfHalf( ); t.y = randMinusHalfHalf( ); t.z = randMinusHalfHalf( );
                d = dot(t, t);
        }
        while( d == 0.0f || d > 1.0f );

        t.normalize( );
        return t;
}

//==============================================================
//==============================================================

Vector3 SS::randOnSphere( float radius )
{
        return randOnSphere() * radius;
}

//==============================================================
//==============================================================

Vector3 SS::randInSphere( )
{
        //distribution is uniform when random vectors inside a unit sphere are normalized
        Vector3 t;
        float d;
        do
        {
                t.x = randMinusHalfHalf( ); t.y = randMinusHalfHalf( ); t.z = randMinusHalfHalf( );
                d = dot(t, t);
        }
        while( d > 1.0f );
        return t;
}

//==============================================================
//==============================================================

Vector3 SS::randInSphere( float radius )
{
        return randInSphere() * radius;
}

//==============================================================
//==============================================================

Vector2 SS::randInCircle( )
{
        //distribution is uniform when random vectors inside a unit sphere are normalized
        Vector2 t;
        float d;
        do
        {
                t.x = randMinusHalfHalf( ); t.y = randMinusHalfHalf( );
                d = dot(t, t);
        }
        while( d > 1.0f );
        return t;
}

//==============================================================
//==============================================================

Vector3 SS::perpendicular( const Vector3 &v )
{
        Vector3 t;
        //select the shortest of projections of axes on v (the closest to perpendicular to v),
        // and project it to the plane defined by v
        if( fabs(v.x) < fabs(v.y) )
        {       //x < y
                if( fabs(v.x) < fabs(v.z) )
                {       // x < y && x < z
                        t.x = 1.0f - v.x * v.x;
                        t.y = -v.x * v.y;
                        t.z = -v.x * v.z;
                        return t;
                }
        }
        else
        {       //y <= x
                if( fabs(v.y) < fabs(v.z) )
                {       // y <= x && y < z
                        t.x = -v.y * v.x;
                        t.y = 1.0f - v.y * v.y;
                        t.z = -v.y * v.z;
                        return t;
                }
        }

        //z <= x && z <= y
        t.x = -v.z * v.x;
        t.y = -v.z * v.y;
        t.z = 1.0f - v.z * v.z;
        return t;
}

//==============================================================
//==============================================================

---