/Users/kfitz/Projects/Loris/Loris development/src/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-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
 *
 *
 * 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"
#include "LinearEnvelope.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 setPhaseCorrect( bool correctPhase );
        
//      --- resampling ---

    void resample( Partial & p ) const;

    void operator() ( Partial & p ) const 
    { 
        resample( p ); 
    }
    
    void resample( Partial & p, const LinearEnvelope & timingEnv ) const;
    
    void quantize( Partial & p ) const;

         
#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 ); 
        }
 
#if ! defined(NO_TEMPLATE_MEMBERS)
        template<typename Iter>
        void resample( Iter begin, Iter end, const LinearEnvelope & timingEnv ) const;
#else
   inline 
        void resample( PartialList::iterator begin, PartialList::iterator end,
                       const LinearEnvelope & timingEnv) const;
#endif   

#if ! defined(NO_TEMPLATE_MEMBERS)
        template<typename Iter>
        void quantize( Iter begin, Iter end ) const;
#else
   inline 
        void quantize( PartialList::iterator begin, PartialList::iterator end  ) const;
#endif   
         
// -- 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 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 (sequence of Partials, with timing envelope)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void Resampler::resample( Iter begin, Iter end, const LinearEnvelope & timingEnv ) const
#else
inline 
void Resampler::resample( PartialList::iterator begin, PartialList::iterator end, 
                          const LinearEnvelope & timingEnv  ) const
#endif   
{
        while ( begin != end )
        {
                resample( *begin++, timingEnv );
        }
}

// ---------------------------------------------------------------------------
//      quantize (sequence of Partials)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void Resampler::quantize( Iter begin, Iter end ) const
#else
inline 
void Resampler::quantize( PartialList::iterator begin, PartialList::iterator end  ) const
#endif   
{
        while ( begin != end )
        {
                quantize( *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 );
    
    if ( denseResampling )
    {
        instance.resample( begin, end );
    }
    else
    {
        instance.quantize( begin, end );
    }
}

}       //      end of namespace Loris

#endif /* ndef INCLUDE_RESAMPLER_H */

---