SpectralSurface.h

#ifndef INCLUDE_SPECTRALSURFACE_H
#define INCLUDE_SPECTRALSURFACE_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
 *
 *
 * SpectralSurface.h
 *
 * Definition of class SpectralSurface, a class representing 
 * a smoothed time-frequency surface that can be used to 
 * perform cross-synthesis, the filtering of one sound by the
 * time-varying spectrum of another.
 *
 * Kelly Fitz, 21 Dec 2005
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */

#include "LorisExceptions.h"
#include "Partial.h"
#include "PartialList.h"
#include "PartialUtils.h"   // for compareLabelLess

#include <algorithm>        // for sort
#include <vector>

//  begin namespace
namespace Loris {

// ---------------------------------------------------------------------------
//  Class SpectralSurface
//
//
class SpectralSurface
{
//  -- public interface --
public:
    
//  -- lifecycle --

#if ! defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    SpectralSurface( Iter b, Iter e );
#else
    inline
    SpectralSurface( PartialList::iterator b, PartialList::iterator e );
#endif    

    //  use compiler-generated copy/assign/destroy

// --- operations ---
    
    void scaleAmplitudes( Partial & p );

#if ! defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    void scaleAmplitudes( Iter b, Iter e );
#else
    inline
    void scaleAmplitudes( PartialList::iterator b, PartialList::iterator e );
#endif
    
    void setAmplitudes( Partial & p );
    
#if ! defined(NO_TEMPLATE_MEMBERS)
    template<typename Iter>
    void setAmplitudes( Iter b, Iter e );
#else
    inline
    void setAmplitudes( PartialList::iterator b, PartialList::iterator e );
#endif
    
// --- access/mutation ---

    double frequencyStretch( void ) const;
    
    double timeStretch( void ) const;
    
    double effect( void ) const;
    
    void setFrequencyStretch( double stretch );

    void setTimeStretch( double stretch );
    
    void setEffect( double effect );
    
private:

//  -- instance variables --

    std::vector< Partial > mPartials;   

    double mStretchFreq;                
    double mStretchTime;                
    double mEffect;                     



    double mMaxSurfaceAmp;              


    
// --- private helpers ---

    //  helper used by constructor for adding Partials one by one
    void addPartialAux( const Partial & p );
    
};

// ---------------------------------------------------------------------------
//    constructor
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
SpectralSurface::SpectralSurface( Iter b, Iter e ) :
#else
inline
SpectralSurface::SpectralSurface( PartialList::iterator b, 
                                  PartialList::iterator e ) :
#endif    
    mStretchFreq( 1.0 ),
    mStretchTime( 1.0 ),
    mEffect( 1.0 ),
    mMaxSurfaceAmp( 0.0 )
{
    //  add only labeled Partials:
    while ( b != e )
    {
        if ( b->label() != 0 )
        {
            addPartialAux( *b );
        }
        ++b;
    }
    
    // complain if the Partials were not distilled
    if ( mPartials.empty() )
    {
        Throw( InvalidArgument, "Partals need to be distilled to build a SpectralSurface" );
    }

    if ( 0 == mMaxSurfaceAmp )
    {
        Throw( InvalidArgument, "The SpectralSurface is zero amplitude everywhere!" );
    }
    
    // sort by label
    std::sort( mPartials.begin(), mPartials.end(), PartialUtils::compareLabelLess() );
}


// ---------------------------------------------------------------------------
//    scaleAmplitudes
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void SpectralSurface::scaleAmplitudes( Iter b, Iter e )
#else
inline
void SpectralSurface::scaleAmplitudes( PartialList::iterator b, 
                                       PartialList::iterator e )
#endif
{   
    while ( b != e )
    {
        // debugger << b->label() << endl;
        scaleAmplitudes( *b );
        ++b;
    }   
}

// ---------------------------------------------------------------------------
//    setAmplitudes
// ---------------------------------------------------------------------------
//
#if ! defined(NO_TEMPLATE_MEMBERS)
template<typename Iter>
void SpectralSurface::setAmplitudes( Iter b, Iter e )
#else
inline
void SpectralSurface::setAmplitudes( PartialList::iterator b, 
                                     PartialList::iterator e )
#endif
{   
    while ( b != e )
    {
        // debugger << b->label() << endl;
        setAmplitudes( *b );
        ++b;
    }   
}

}   // namespace Loris

#endif /* ndef INCLUDE_SPECTRALSURFACE_H */

---