zernike.cpp

Go to the documentation of this file.

/** \file zernike.cpp
 * \author Jared R. Males (jaredmales@gmail.com)
 * \brief Working with the Zernike polynomials.
 *
 * \ingroup signal_processing_files
 *
 */
 
//***********************************************************************//
// Copyright 2021 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "sigproc/zernike.hpp"
 
namespace mx
{
namespace sigproc
{
 
int noll_nm( int &n, int &m, int j )
{
    if( j < 1 )
    {
        internal::mxlib_error_report(error_t::invalidarg, "The Noll index j cannot be less than 1 in the Zernike polynomials" );
        return -1;
    }
 
    n = ceil( -1.5 + sqrt( 0.25 + 2 * j ) - 1e-10 ); // 1e-10 is to avoid wrong rounding due to numerical precision
 
    int jrem = j - ( n * ( n + 1 ) / 2 + 1 );
    m = ( jrem + ( jrem % 2 ) * abs( ( n % 2 ) - 1 ) + fabs( ( jrem % 2 ) - 1 ) * ( n % 2 ) ) *
        ( -math::func::sign( ( j % 2 ) - 0.5 ) );
 
    return 0;
}
 
int noll_j( unsigned int n, int m )
{
    if( ( ( n - m ) % 2 ) )
        return -1; // Check if odd
 
    int mn = n % 4;
 
    int dm = 0;
    if( m >= 0 && ( mn == 2 || mn == 3 ) )
        dm = 1;
    else if( m <= 0 && ( mn == 0 || mn == 1 ) )
        dm = 1;
 
    int j = ( n * ( n + 1 ) ) / 2 + abs( m ) + dm;
 
    return j;
}
 
int nZernRadOrd( unsigned int n )
{
    if( n % 2 ) // odd
    {
        return noll_j( n, -n );
    }
    else
    {
        return noll_j( n, n );
    }
}
 
// Explicit instantiations:
template int zernikeRCoeffs<float>( std::vector<float> &c, int n, int m );
 
template int zernikeRCoeffs<double>( std::vector<double> &c, int n, int m );
 
template int zernikeRCoeffs<long double>( std::vector<long double> &c, int n, int m );
 
#ifdef HASQUAD
template int zernikeRCoeffs<__float128>( std::vector<__float128> &c, int n, int m );
#endif
 
template float zernikeR<float, double>( float rho, int n, int m, std::vector<double> &c );
 
template double zernikeR<double, double>( double rho, int n, int m, std::vector<double> &c );
 
template long double zernikeR<long double, long double>( long double rho, int n, int m, std::vector<long double> &c );
 
#ifdef HASQUAD
template __float128 zernikeR<__float128, __float128>( __float128 rho, int n, int m, std::vector<__float128> &c );
#endif
 
template float zernikeR<float, double>( float rho, int n, int m );
 
template double zernikeR<double, double>( double rho, int n, int m );
 
template long double zernikeR<long double, long double>( long double rho, int n, int m );
 
#ifdef HASQUAD
template __float128 zernikeR<__float128, __float128>( __float128 rho, int n, int m );
#endif
 
template float zernike<float, double>( float rho, float phi, int n, int m, std::vector<double> &c );
 
template double zernike<double, double>( double rho, double phi, int n, int m, std::vector<double> &c );
 
template long double
zernike<long double, long double>( long double rho, long double phi, int n, int m, std::vector<long double> &c );
 
#ifdef HASQUAD
template __float128
zernike<__float128, __float128>( __float128 rho, __float128 phi, int n, int m, std::vector<__float128> &c );
#endif
 
template float zernike<float, double>( float rho, float phi, int n, int m );
 
template double zernike<double, double>( double rho, double phi, int n, int m );
 
template long double zernike<long double, long double>( long double rho, long double phi, int n, int m );
 
#ifdef HASQUAD
template __float128 zernike<__float128, __float128>( __float128 rho, __float128 phi, int n, int m );
#endif
 
template float zernike<float, double>( float rho, float phi, int j );
 
template double zernike<double, double>( double rho, double phi, int j );
 
template long double zernike<long double, long double>( long double rho, long double phi, int j );
 
#ifdef HASQUAD
template __float128 zernike<__float128, __float128>( __float128 rho, __float128 phi, int j );
#endif
 
template float zernikeQNorm<float>( float k, float phi, int n, int m );
 
template double zernikeQNorm<double>( double k, double phi, int n, int m );
 
template long double zernikeQNorm<long double>( long double k, long double phi, int n, int m );
 
#ifdef HASQUAD
template __float128 zernikeQNorm<__float128>( __float128 k, __float128 phi, int n, int m );
#endif
 
} // namespace sigproc
} // namespace mx