Resampler.h

#ifndef INCLUDE_RESAMPLER_H
#define INCLUDE_RESAMPLER_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-2007 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
 *
 *
 * Resampler.h
 *
 * Definition of class Resampler, for converting reassigned Partial envelopes
 * into more conventional additive synthesis envelopes, having data points
 * at regular time intervals. The benefits of reassigned analysis are NOT
 * lost in this process, since the elimination of unreliable data and the
 * reduction of temporal smearing are reflected in the resampled data.
 *
 * Lippold, 7 Aug 2003
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */

#include "PartialList.h"

//  begin namespace
namespace Loris {

class Partial;

// ---------------------------------------------------------------------------
//  class Resampler
//
//
class Resampler
{
//  --- public interface ---
public:
//  --- lifecycle ---

    explicit Resampler( double sampleInterval );

    // use compiler-generated copy/assign/destroy
    
//  --- parameters ---

    void setDenseResampling( bool useDense );
    
    void setPhaseCorrect( bool correctPhase );
        
//  --- resampling ---

    void resample( Partial & p ) const;

    void operator() ( Partial & p ) const 
    { 
        resample( p ); 
    }
     
#if ! defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    void resample( Iter begin, Iter end ) const;
#else
   inline 
    void resample( PartialList::iterator begin, PartialList::iterator end  ) const;
#endif   

#if ! defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    void operator()( Iter begin, Iter end ) const
#else
    void operator()( PartialList::iterator begin, PartialList::iterator end  ) const
#endif   
    { 
       resample( begin, end ); 
    }
         
// -- static members --

#if ! defined(NO_TEMPLATE_MEMBERS)
    template< typename Iter >
    static 
    void resample( Iter begin, Iter end, double sampleInterval, 
                   bool denseResampling = false );
#else
    static inline 
    void resample( PartialList::iterator begin, PartialList::iterator end,
                  double sampleInterval, bool denseResampling = false );
#endif   

//  --- instance variables ---
private:

    double interval_;   

    bool dense_;
    
    bool phaseCorrect_;
    
};  //  end of class Resampler

// ---------------------------------------------------------------------------
//  resample (sequence of Partials)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void Resampler::resample( Iter begin, Iter end ) const
#else
inline 
void Resampler::resample( PartialList::iterator begin, PartialList::iterator end  ) const
#endif   
{
    while ( begin != end )
    {
        resample( *begin++ );
    }
}

// ---------------------------------------------------------------------------
//  resample (static)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template< typename Iter >
void Resampler::resample( Iter begin, Iter end, double sampleInterval, 
                          bool denseResampling )
#else
inline
void Resampler::resample( PartialList::iterator begin, PartialList::iterator end,
                          double sampleInterval, bool denseResampling )
#endif   
{
    Resampler instance( sampleInterval );
    instance.setDenseResampling( denseResampling ); 
    instance.resample( begin, end );
}

}   //  end of namespace Loris

#endif /* ndef INCLUDE_RESAMPLER_H */

---