Morpher.h

#ifndef INCLUDE_MORPHER_H
#define INCLUDE_MORPHER_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
 *
 *
 * Morpher.h
 *
 * Definition of class Morpher.
 *
 * Kelly Fitz, 15 Oct 1999
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */
#include "PartialList.h"
#include "Partial.h"

#include <memory>   // for auto_ptr

//  begin namespace
namespace Loris {

class Envelope;

// ---------------------------------------------------------------------------
//  Class Morpher
//
//
class Morpher
{
//  -- instance variables --

    std::auto_ptr< Envelope > _freqFunction;  
    std::auto_ptr< Envelope > _ampFunction;   
    std::auto_ptr< Envelope > _bwFunction;    
    
    PartialList _partials;                    
    
    Partial::label_type _refLabel0;  
    Partial::label_type _refLabel1;  



    double _freqFixThresholdDb;      


    
    double _ampMorphShape;           










                                                                        
    double _minBreakpointGapSec;     







//  -- public interface --
public:
//  -- construction --

    Morpher( const Envelope & f );

    Morpher( const Envelope & ff, const Envelope & af, const Envelope & bwf );

    Morpher( const Morpher & rhs );
    
    ~Morpher( void );
    
    Morpher & operator= ( const Morpher & rhs );

//  -- morphed parameter computation --

//  -- Partial morphing --

    Partial morphPartial( const Partial & src, const Partial & tgt, 
                          int assignLabel );

    void morph( PartialList::const_iterator beginSrc, 
                PartialList::const_iterator endSrc,
                PartialList::const_iterator beginTgt, 
                PartialList::const_iterator endTgt );

    void crossfade( PartialList::const_iterator beginSrc, 
                    PartialList::const_iterator endSrc,
                    PartialList::const_iterator beginTgt, 
                    PartialList::const_iterator endTgt,
                    Partial::label_type label = 0 );


    //
    Breakpoint
    morphBreakpoints( const Breakpoint & srcBkpt, const Breakpoint & tgtBkpt, 
                      double time  ) const;
                               
    Breakpoint 
    morphSrcBreakpoint( const Breakpoint & bp, const Partial & tgtPartial, 
                        double time ) const;

    Breakpoint 
    morphTgtBreakpoint( const Breakpoint & bp, const Partial & srcPartial, 
                        double time ) const;

    Breakpoint fadeSrcBreakpoint( Breakpoint bp, double time ) const;

    Breakpoint fadeTgtBreakpoint( Breakpoint bp, double time ) const;
    
//  -- morphing function access/mutation --

    void setFrequencyFunction( const Envelope & f );
    
    void setAmplitudeFunction( const Envelope & f );
    
    void setBandwidthFunction( const Envelope & f );

    const Envelope & frequencyFunction( void ) const;
    
    const Envelope & amplitudeFunction( void ) const;
    
    const Envelope & bandwidthFunction( void ) const;
    
    double amplitudeShape( void ) const;
    
    void setAmplitudeShape( double x );
    
    double minBreakpointGap( void ) const;

    void setMinBreakpointGap( double x );


//  -- reference Partial label access/mutation --
    
    Partial::label_type sourceReferenceLabel( void ) const;
    
    Partial::label_type targetReferenceLabel( void ) const;
    
    void setSourceReferenceLabel( Partial::label_type l );
    
    void setTargetReferenceLabel( Partial::label_type l );
    
//  -- PartialList access --

    PartialList & partials( void ); 

    const PartialList & partials( void ) const; 
                    
private:
    
//  -- helper --

    //  PartialCorrespondence represents a map from non-zero Partial 
    //  labels to pairs of pointers to Partials that should be morphed 
    //  into a single Partial that is assigned that label. 
    //  PartialPtrPair is a pair of pointers to Partials that are
    //  initialized to zero, and it is the element type for the
    //  PartialCorrespondence map.
    struct PartialPtrPair
    {
        const Partial * first;
        const Partial * second;
        PartialPtrPair( void ) : first(0), second(0) {}
    
    };
    typedef std::map< Partial::label_type, PartialPtrPair > PartialCorrespondence;
    
    void morph_aux( PartialCorrespondence & correspondence );
    
    Partial makePartialFromReference( Partial scaleMe, double fscale );

    //
    void appendMorphedSrc( const Breakpoint & srcBkpt, const Partial & tgtPartial, 
                           double time, Partial & newp  );
                           
    //
    void appendMorphedTgt( const Breakpoint & tgtBkpt, const Partial & srcPartial, 
                           double time, Partial & newp  );
                           

};  //  end of class Morpher

}   //  end of namespace Loris

#endif /* ndef INCLUDE_MORPHER_H */

---