/Users/kfitz/Projects/Loris/Loris development/src/Fundamental.h

#ifndef INCLUDE_FUNDAMENTAL_H
#define INCLUDE_FUNDAMENTAL_H
/*
 * This is the Loris C++ Class Library, implementing analysis, 
 * manipulation, and synthesis of digitized sounds using the Reassigned 
 * Bandwidth-Enhanced Additive Sound Model.
 *
 * Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * Fundamental.h
 *
 * Definition of classes for computing an estimate of time-varying
 * fundamental frequency from either a sequence of samples or a
 * collection of Partials using a frequency domain maximum likelihood 
 * algorithm adapted from Quatieri's speech signal processing textbook. 
 *
 * Kelly Fitz, 25 March 2008
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */

#include "LinearEnvelope.h"
#include "PartialList.h"
#include "F0Estimate.h" 

#include <memory>
#include <vector>

//  begin namespace
namespace Loris {

class ReassignedSpectrum;

// ---------------------------------------------------------------------------
//  class FundamentalEstimator
//

class FundamentalEstimator
{
public:

//  -- types --

    typedef F0Estimate value_type;

//  -- constants --    

    enum {
    
        DefaultAmpFloor = -60,          
        
        DefaultAmpRange = 30,           
    
        DefaultFreqCeiling = 4000,      
    
        DefaultPrecisionOver100 = 10,   

        DefaultMinConfidencePct = 90    

    };
    

//  -- lifecycle --

protected:

    FundamentalEstimator( double precisionHz );
                                                        
public: 

    virtual ~FundamentalEstimator( void );    


    //  compiler-generated copy and assignment are OK

  
//  -- parameter access --

    double ampFloor( void ) const;

    double ampRange( void ) const;

    double freqCeiling( void ) const;

    double precision( void ) const;
     
//  -- parameter mutation --

    void setAmpFloor( double x );

    void setAmpRange( double x );

    void setFreqCeiling( double x );

    void setPrecision( double x );


protected:

//  -- parameter member variables --


    double m_precision;         

                                
    double m_ampFloor;          



    
    double m_ampRange;          



        
    double m_freqCeiling;       




};  //  end of base class FundamentalEstimator



// ---------------------------------------------------------------------------
//  class FundamentalFromSamples
//
//
class FundamentalFromSamples : public FundamentalEstimator
{
//  -- public interface --

public:

//  -- lifecycle --

    FundamentalFromSamples( double winWidthHz, 
                            double precisionHz = DefaultPrecisionOver100 * 0.01 );
                            
                            

    ~FundamentalFromSamples( void );

//  -- fundamental frequency estimation --

    //  buildEnvelope
    //
    LinearEnvelope buildEnvelope( const double * sampsBeg, 
                                  const double * sampsEnd, 
                                  double sampleRate, 
                                  double tbeg, double tend, 
                                  double interval,
                                  double lowerFreqBound, double upperFreqBound, 
                                  double confidenceThreshold );
                                 
    //  buildEnvelope
    //
    LinearEnvelope buildEnvelope( const double * sampsBeg, 
                                  unsigned long nsamps,
                                  double sampleRate, 
                                  double tbeg, double tend, 
                                  double interval,
                                  double lowerFreqBound, double upperFreqBound, 
                                  double confidenceThreshold )
    {
        return buildEnvelope( sampsBeg, sampsBeg + nsamps, sampleRate, 
                              tbeg, tend, interval, 
                              lowerFreqBound, upperFreqBound,
                              confidenceThreshold );
    }


    //  buildEnvelope
    //
    LinearEnvelope buildEnvelope( const std::vector< double > & samps, 
                                  double sampleRate, 
                                  double tbeg, double tend, 
                                  double interval,
                                  double lowerFreqBound, double upperFreqBound, 
                                  double confidenceThreshold )
    {
        return buildEnvelope( &samps[0], &samps[0] + samps.size(), sampleRate, 
                              tbeg, tend, interval, 
                              lowerFreqBound, upperFreqBound,
                              confidenceThreshold );
    }

                                 
    //  estimateAt
    //
    
    value_type estimateAt( const double * sampsBeg, 
                           const double * sampsEnd, 
                           double sampleRate, 
                           double time,
                           double lowerFreqBound, double upperFreqBound );

    //  estimateAt
    //
    
    value_type estimateAt( const double * sampsBeg, 
                           unsigned long nsamps,
                           double sampleRate, 
                           double time,
                           double lowerFreqBound, double upperFreqBound )
    {
        return estimateAt( sampsBeg, sampsBeg + nsamps, sampleRate, 
                           time, lowerFreqBound, upperFreqBound );
    }
                           
    //  estimateAt
    //
    
    value_type estimateAt( const std::vector< double > & samps, 
                           double sampleRate, 
                           double time,
                           double lowerFreqBound, double upperFreqBound )
    {
        return estimateAt( &samps[0], &samps[0] + samps.size(), sampleRate, 
                           time, lowerFreqBound, upperFreqBound );
    }
                              


//  -- spectral analysis parameter access/mutation --

    double windowWidth( void ) const;
    
    void setWindowWidth( double w );         

    

//  -- private auxiliary functions --

private: 

    //  buildSpectrumAnalyzer
    //
    void buildSpectrumAnalyzer( double srate );
        

    //  collectFreqsAndAmps
    //
    
    void collectFreqsAndAmps( const double * samps,
                              unsigned long nsamps,
                              double sampleRate,
                              std::vector< double > & frequencies, 
                              std::vector< double > & amplitudes,
                              double time );


//  -- private member variables --

    std::auto_ptr< ReassignedSpectrum > m_spectrum;
                                
    double m_cacheSampleRate;   

    double m_windowWidth;       

    
//  disallow these until they are implemented

    FundamentalFromSamples( const FundamentalFromSamples & );
    FundamentalFromSamples & operator= ( const FundamentalFromSamples & );

};   //  end of class FundamentalFromSamples



// ---------------------------------------------------------------------------
//  class FundamentalFromPartials
//

class FundamentalFromPartials : public FundamentalEstimator
{
//  -- public interface --

public:

//  -- lifecycle --

    FundamentalFromPartials( double precisionHz = DefaultPrecisionOver100 * 0.01 );
                                                        

    ~FundamentalFromPartials( void );
    
    FundamentalFromPartials( const FundamentalFromPartials & );
    
    FundamentalFromPartials & operator= ( const FundamentalFromPartials & );

//  -- fundamental frequency estimation --

    //  buildEnvelope
    //
    LinearEnvelope buildEnvelope( PartialList::const_iterator begin_partials, 
                                  PartialList::const_iterator end_partials,
                                  double tbeg, double tend, 
                                  double interval,
                                  double lowerFreqBound, double upperFreqBound, 
                                  double confidenceThreshold );
                                  
    //  buildEnvelope
    //
    LinearEnvelope buildEnvelope( const PartialList & partials, 
                                  double tbeg, double tend, 
                                  double interval,
                                  double lowerFreqBound, double upperFreqBound, 
                                  double confidenceThreshold )
    {
        return buildEnvelope( partials.begin(), partials.end(),
                              tbeg, tend, interval,
                              lowerFreqBound, upperFreqBound,
                              confidenceThreshold );
    }
    
                                 
    //  estimateAt
    //
    value_type estimateAt( PartialList::const_iterator begin_partials, 
                           PartialList::const_iterator end_partials,
                           double time,
                           double lowerFreqBound, double upperFreqBound );
                           
    //  estimateAt
    //
    value_type estimateAt( const PartialList & partials, 
                           double time,
                           double lowerFreqBound, double upperFreqBound )
    {
            return estimateAt( partials.begin(), partials.end(),
                               time,
                               lowerFreqBound, upperFreqBound );
    }



//  -- private auxiliary functions --

private: 

    //  collectFreqsAndAmps
    //
    void collectFreqsAndAmps( PartialList::const_iterator begin_partials, 
                              PartialList::const_iterator end_partials,
                              std::vector< double > & frequencies, 
                              std::vector< double > & amplitudes,
                              double time );



};   //  end of class FundamentalFromPartials



}   //  end of namespace Loris

#endif  // ndef INCLUDE_FUNDAMENTAL_H

---