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-2004 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 */

---