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

#ifndef INCLUDE_DILATOR_H
#define INCLUDE_DILATOR_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
 *
 *
 * Dilator.h
 *
 * Definition of class Dilator.
 *
 * Kelly Fitz, 26 Oct 1999
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */

#if defined(NO_TEMPLATE_MEMBERS)
#include "PartialList.h"
#endif

#include <vector>

//      begin namespace
namespace Loris {

class Marker;
class Partial;

// ---------------------------------------------------------------------------
//      class Dilator
//
//
class Dilator
{
//      -- instance variables --

        std::vector< double > _initial, _target;        //      time points
        
//      -- public interface --
public:
//      -- construction --

        Dilator( void );
                
#if ! defined(NO_TEMPLATE_MEMBERS)
        template<typename Iter1, typename Iter2>
        Dilator( Iter1 ibegin, Iter1 iend, Iter2 tbegin );
#else
    inline
        Dilator( const double * ibegin, const double * iend, const double * tbegin );
#endif

        //      Use compiler-generated copy, assign, and destroy.
        
//      -- mutation --
        
        void insert( double i, double t );
        
//      -- dilation --

        void dilate( Partial & p ) const;
         
        void operator() ( Partial & p ) const;

        void dilate( Marker & m ) const;
         
        void operator() ( Marker & m ) const;
         
#if ! defined(NO_TEMPLATE_MEMBERS)
        template<typename Iter>
        void dilate( Iter dilate_begin, Iter dilate_end  ) const;
#else
    inline
        void dilate( PartialList::iterator dilate_begin, 
                                    PartialList::iterator dilate_end  ) const;
#endif
         
#if ! defined(NO_TEMPLATE_MEMBERS)
        template<typename Iter>
        void operator() ( Iter dilate_begin, Iter dilate_end  ) const;
#else
    inline
        void operator() ( PartialList::iterator dilate_begin, 
                                              PartialList::iterator dilate_end ) const;
#endif
         
    double warpTime( double currentTime ) const;

// -- static members --

#if ! defined(NO_TEMPLATE_MEMBERS)
        template< typename PartialsIter, typename TimeIter1, typename TimeIter2 >
        static 
        void dilate( PartialsIter dilate_begin, PartialsIter dilate_end,
                     TimeIter1 ibegin, TimeIter1 iend, TimeIter2 tbegin  );
#else
    static inline
        void dilate( PartialList::iterator dilate_begin, 
                                 PartialList::iterator dilate_end,
                                 const double * ibegin, const double * iend, 
                                 const double * tbegin  );
#endif

};      //      end of class Dilator


// ---------------------------------------------------------------------------
//      constructor (sequences of time points)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter1, typename Iter2>
Dilator::Dilator( Iter1 ibegin, Iter1 iend, Iter2 tbegin )
#else
inline
Dilator::Dilator( const double * ibegin, const double * iend, const double * tbegin )
#endif
{
        while ( ibegin != iend )
        {
                insert( *ibegin++, *tbegin++ );
        }
}

// ---------------------------------------------------------------------------
//      dilate (sequence of Partials or Markers)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void Dilator::dilate( Iter dilate_begin, Iter dilate_end  ) const
#else
inline
void Dilator::dilate( PartialList::iterator dilate_begin, 
                                          PartialList::iterator dilate_end  ) const
#endif
{
        while ( dilate_begin != dilate_end )
        {
                dilate( *(dilate_begin++) );
        }
}

// ---------------------------------------------------------------------------
//      Function call operator (sequence of Partials or Markers)
// ---------------------------------------------------------------------------
//       
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void Dilator::operator() ( Iter dilate_begin, Iter dilate_end  ) const
#else
inline
void Dilator::operator() ( PartialList::iterator dilate_begin, 
                                                   PartialList::iterator dilate_end ) const
#endif
{ 
        dilate( dilate_begin, dilate_end ); 
}

// ---------------------------------------------------------------------------
//      Function call operator (single Partial)
// ---------------------------------------------------------------------------
//
inline 
void Dilator::operator() ( Partial & p ) const
{ 
        dilate( p ); 
}

// ---------------------------------------------------------------------------
//      Function call operator (single Marker)
// ---------------------------------------------------------------------------
//
inline 
void Dilator::operator() ( Marker & m ) const
{ 
        dilate( m ); 
}

// ---------------------------------------------------------------------------
//      dilate (static)
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template< typename PartialsIter, typename TimeIter1, typename TimeIter2 >
void Dilator::dilate( PartialsIter dilate_begin, PartialsIter dilate_end,
                                          TimeIter1 ibegin, TimeIter1 iend, TimeIter2 tbegin  )
#else
inline
void Dilator::dilate( PartialList::iterator dilate_begin, 
                                          PartialList::iterator dilate_end,
                                          const double * ibegin, const double * iend, 
                                          const double * tbegin  )
#endif
{ 
        Dilator instance( ibegin, iend, tbegin );
        instance.dilate( dilate_begin, dilate_end ); 
}

}       //      end of namespace Loris

#endif /* ndef INCLUDE_DILATOR_H */

---