array2FitGaussian1D.hpp

Go to the documentation of this file.

/** \file array2FitGaussian1D.hpp
  * \author Jared R. Males
  * \brief Wrapper for a native array to pass to \ref levmarInterface, with 1D Gaussian details.
  * \ingroup fitting_files
  *
  */
 
//***********************************************************************//
// Copyright 2022 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/>.
//***********************************************************************//
 
#ifndef math_fit_array2FitGaussian1D_hpp
#define math_fit_array2FitGaussian1D_hpp
 
#include "../../mxError.hpp"
 
namespace mx
{
namespace math
{
namespace fit
{
 
 
/// Wrapper for a native array to pass to \ref levmarInterface, with !D Gaussian details.
/** Supports fixing G0, G, x0, and sigma independently.  
  * \ingroup gaussian_peak_fit
  */
template<typename realT>
struct array2FitGaussian1D
{
   realT * m_data {nullptr};   ///< ///< Pointer to the array of y values
   realT * m_coords {nullptr}; ///< Pointer to the array of x values (optional)
   size_t m_nx {0};            ///< X dimension of the array
   
   realT * m_mask {nullptr};     ///< Pointer to the (optional) mask array.  Any 0 pixels are excluded from the fit.
   
   realT m_G0 {0};
   realT m_G {0};
   realT m_x0 {0};
   realT m_sigma {0};
      
   int m_G0_idx {0};
   int m_G_idx {1};
   int m_x0_idx {2};
   int m_sigma_idx {3}; 
   
   int m_nparams {4};
   int m_maxNparams {4};
   
   /// Set whether each parameter is fixed.
   /** Sets the parameter indices appropriately.
     */
   void setFixed( bool G0, 
                  bool G, 
                  bool x0, 
                  bool sigma 
                );
   
   realT G0( realT * p );
   
   void G0( realT * p,
            realT nG0
          );
   
   realT G( realT * p );
   
   void G( realT * p,
           realT nG
         );
   
   realT x0( realT * p );
   
   void x0( realT * p,
            realT nx0
          );
      
   realT sigma( realT * p );
   
   void sigma( realT * p,
                 realT nsigma_x
               );   
      
   int nparams();
   
};
 
template<typename realT>
void array2FitGaussian1D<realT>::setFixed( bool G0, 
                                           bool G, 
                                           bool x0, 
                                           bool sigma
                                         )
{
   int idx = 0;
   
   if(G0) m_G0_idx = -1;
   else m_G0_idx = idx++;
   
   if(G) m_G_idx = -1;
   else m_G_idx = idx++;
 
   if(x0) m_x0_idx = -1;
   else m_x0_idx = idx++;
   
   if(sigma) m_sigma_idx = -1;
   else m_sigma_idx = idx++;
   
   m_nparams = idx;
}
 
template<typename realT>
realT array2FitGaussian1D<realT>::G0( realT * p )
{
   if( m_G0_idx < 0 )
   {
      return m_G0;
   }
   else
   {
      return p[m_G0_idx];
   }
}
 
template<typename realT>
void array2FitGaussian1D<realT>::G0( realT * p,
                                     realT nG0
                                   )
{
   if( m_G0_idx < 0 )
   {
      m_G0 = nG0;
   }
   else
   {
      p[m_G0_idx]=nG0;
   }
}
 
template<typename realT>
realT array2FitGaussian1D<realT>::G( realT * p )
{
   if( m_G_idx < 0 )
   {
      return m_G;
   }
   else
   {
      return p[m_G_idx];
   }
}
 
template<typename realT>
void array2FitGaussian1D<realT>::G( realT * p,
        realT nG
      )
{
   if( m_G_idx < 0 )
   {
      m_G = nG;
   }
   else
   {
      p[m_G_idx] = nG;
   }
}
 
template<typename realT>
realT array2FitGaussian1D<realT>::x0( realT * p )
{
   if( m_x0_idx < 0 )
   {
      return m_x0;
   }
   else
   {
      return p[m_x0_idx];
   }
}
 
template<typename realT>
void array2FitGaussian1D<realT>::x0( realT * p,
                                     realT nx0
                                   )
{
   if( m_x0_idx < 0 )
   {
      m_x0 = nx0;
   }
   else
   {
      p[m_x0_idx] = nx0;
   }
}
 
template<typename realT>
realT array2FitGaussian1D<realT>::sigma( realT * p )
{
   if( m_sigma_idx < 0 )
   {
      return m_sigma;
   }
   else
   {
      return p[m_sigma_idx];
   }
}
 
template<typename realT>
void array2FitGaussian1D<realT>::sigma( realT * p,
                                        realT nsigma
                                      )
{
   if( m_sigma_idx < 0 )
   {
      m_sigma = nsigma;
   }
   else
   {
      p[m_sigma_idx] = nsigma;
   }
}
 
template<typename realT>
int array2FitGaussian1D<realT>::nparams()
{
   return m_nparams;
}
 
} //namespace fit
} //namespace math
 
} //namespace mx
 
#endif //math_fit_array2FitGaussian1D_hpp