SHDevice.h

Go to the documentation of this file.

#ifndef _ZFXMATH_INCLUDE_SH_DEVICE_H_
#define _ZFXMATH_INCLUDE_SH_DEVICE_H_

#include <assert.h>
#include "SphericalHarmonics.h"
#include "SHRotateMatrix.h"
#include "SHRotate.h"
#include "NRook.h"

namespace ZFXMath
{

namespace SphericalHarmonics
{

template< class PrecisionType, class FuncValueType >
struct TDevice
{
    TDevice( int numBands, int numSamples ) :
        m_NumBands( numBands ),
        m_NumSamples( numSamples )
    {
        assert( numBands > 0 );
        assert( numSamples > 0 );

        // Generate the sphere samples
        m_Samples = GenerateSamples<PrecisionType>( m_NumSamples );

        // Create an allocator with enough space to store y(l,m) over each band for each sample
        m_CoeffsAllocator = new TCoeffs<PrecisionType>::Allocator( m_NumSamples * m_NumBands * m_NumBands );

        // Allocate a set of empty coeff lists
        m_SHValues = new TCoeffs<PrecisionType>[m_NumSamples];

        for (int i = 0; i < m_NumSamples; i++)
        {
            // De-ref current sample
            TSample<PrecisionType>& s = m_Samples[i];

            // Create an SH coefficients to store the required number of bands
            TCoeffs<PrecisionType>& sh = m_SHValues[i] = TCoeffs<PrecisionType>( m_NumBands, m_CoeffsAllocator );

            // Record all y(l,m) for this sample
            for (int l = 0; l < m_NumBands; l++)
                for (int m = -l; m <= l; m++)
                    sh(l, m) = y<PrecisionType>(l, m, s.theta, s.phi);
        }
    }

    ~TDevice()
    {
        delete m_CoeffsAllocator;
        delete[] m_SHValues;    
    }

    void Project(const TSphericalFunction< PrecisionType, FuncValueType >& func,
                 TCoeffs< FuncValueType >& dest )
    {
        SphericalHarmonics::Project( func, m_Samples, m_SHValues, m_NumSamples, dest );
    }

    private:

        // Number of samples on the sphere
        int                                         m_NumSamples;

        // Number of SH bands
        int                                         m_NumBands;

        // Uniformly distributed samples on the sphere
        TSample<PrecisionType>*                     m_Samples;

        // Allocator for y(l,m) values for each sample
        typename TCoeffs<PrecisionType>::Allocator* m_CoeffsAllocator;

        // y(l,m) stored for each sample over m_NumBands
        TCoeffs<PrecisionType>*                     m_SHValues;
    
};

}; // namespace SphericalHarmonics

}; // namespace ZFXMath

#endif //_ZFXMATH_INCLUDE_SH_DEVICE_H__

---