SHRotateMatrix.h

gehe zur Dokumentation dieser Datei

#ifndef _ZFXMATH_INCLUDE_SH_ROTATEMATRIX_H_
#define _ZFXMATH_INCLUDE_SH_ROTATEMATRIX_H_

namespace ZFXMath
{

namespace SphericalHarmonics
{

template<class PrecisionType, class FuncValueType>
class TRotateMatrix
{
public:
    TRotateMatrix(const int nb_bands) :

        m_NbBands(nb_bands),
        m_Matrices(0),
        m_Elements(0)

    {
        m_Matrices = (SubMatrix*)operator new (m_NbBands * sizeof(SubMatrix));

        int size = 0;
        for (int i = 0; i < m_NbBands; i++)
            size += (i * 2 + 1) * (i * 2 + 1);

        m_Elements = new PrecisionType[size];

        for (int i = 0, j = 0; i < m_NbBands; i++)
        {
            int w = i * 2 + 1;
            m_Matrices[i] = *new SubMatrix(m_Elements + j, w);
            j += (w * w);
        }

        // The first 1x1 sub-matrix is always 1 and so doesn't need to be stored in the rotation matrix
        // It's stored simply to make the indexing logic as easy as possible
        m_Elements[0] = 1;
    }


    ~TRotateMatrix(void)
    {
        if (m_Elements)
            delete [] m_Elements;
        if (m_Matrices)
            delete [] m_Matrices;
    }


    // Element accessors which take the band index and (+,-) index relative to the centre of the sub-matrix
    PrecisionType&  operator () (const int l, const int m, const int n)
    {
        return (m_Matrices[l](m, n));
    }
    PrecisionType operator () (const int l, const int m, const int n) const
    {
        return (m_Matrices[l](m, n));
    }


    int GetNbBands(void) const
    {
        return (m_NbBands);
    }

    void Transform(const TCoeffs<FuncValueType>& source, TCoeffs<FuncValueType>& dest) const
    {
        // Check number of bands match
        int nb_bands = source.GetNbBands();
        assert(nb_bands == dest.GetNbBands());

        // Band 0 is always multiplied by 1 so it stays untouched
        dest(0) = source(0);

        // Loop through each band
        for (int l = 1; l < nb_bands; l++)
        {
            SubMatrix& M = m_Matrices[l];

            // Calculate band offset into coeff list
            int band_offset = l * (l + 1);

            // Now through each argument of the destination coeff-list
            for (int mo = -l; mo <= l; mo++)
            {
                // Clear destination
                FuncValueType& d = dest(band_offset + mo);
                d = 0;

                // Pre-calculate of mo's lookup in the sub-matrix, plus mi's shift
                int p_mo = (mo + M.GetShift()) * M.GetWidth() + M.GetShift();

                // Multiply-add with each argument of the source coeff-list
                for (int mi = -l; mi <= l; mi++)
                    d += source(band_offset + mi) * FuncValueType( M(p_mo + mi) );
            }
        }
    }

    private:
        class SubMatrix;

        // Number of bands stored
        int         m_NbBands;

        // Sub-matrix for each band
        SubMatrix*  m_Matrices;

        // Element array for each sub-matrix
        PrecisionType*          m_Elements;

        class SubMatrix
        {
        public:
            // Construct that needs previously allocated element array
            SubMatrix(PrecisionType* elements, const int width)  :

            m_Elements(elements),
                m_Width(width),
                m_Size(width * width),
                m_Shift((width - 1) / 2)

            {
            }


            // Element accessors with (+,-) lookup
            PrecisionType& operator () (const int m, const int n)
            {
                return (m_Elements[Index(m, n)]);
            }
            PrecisionType operator () (const int m, const int n) const
            {
                return (m_Elements[Index(m, n)]);
            }


            // Linear element accessors
            PrecisionType& operator () (const int i)
            {
                return (m_Elements[Index(i)]);
            }
            PrecisionType operator () (const int i) const
            {
                return (m_Elements[Index(i)]);
            }


            int GetWidth(void) const
            {
                return (m_Width);
            }

            int GetShift(void) const
            {
                return (m_Shift);
            }


        private:

            int Index(const int m, const int n) const
            {
                // Check bounds in debug build
                assert(m >= -m_Shift && m <= m_Shift);
                assert(n >= -m_Shift && n <= m_Shift);

                return ((m + m_Shift) * m_Width + (n + m_Shift));
            }

            int Index(const int i) const
            {
                // Check bounds in debug build
                assert(i >= 0 && i < m_Size);

                return (i);
            }

            // Element array
            PrecisionType*      m_Elements;

            // Width of the sub-matrix
            int     m_Width;

            // Total size of the sub-matrix in multiples of PrecisionType
            int     m_Size;

            // Value to shift incoming matrix indices by
            int     m_Shift;
        };

}; // class TRotateMatrix

}; // namespace SphericalHarmonics

}; // namespace ZFXMath

#endif //_ZFXMATH_INCLUDE_SH_ROTATEMATRIX_H__

---