/Users/kfitz/Projects/Loris/Loris development/src/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-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
 *
 *
 * 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 _srcRefPartial;         
    Partial _tgtRefPartial;         




    double _freqFixThresholdDb;     


    
    double _logMorphShape;          







                                                            
    double _minBreakpointGapSec;    







                                    
                                    
    bool _doLogAmpMorphing;         


                                    
    bool _doLogFreqMorphing;        


    
    
//  -- 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 morphPartials( Partial src, Partial tgt, int assignLabel );
    
    Partial morphPartial( Partial src, Partial tgt, int assignLabel )
        { return morphPartials( src, tgt, 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( Breakpoint srcBkpt, 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 );
    
    void enableLogAmpMorphing( bool enable = true ) { _doLogAmpMorphing = enable; }
    
    void enableLogFreqMorphing( bool enable = true )  { _doLogFreqMorphing = enable; }
    
    
    double minBreakpointGap( void ) const;

    void setMinBreakpointGap( double x );


//  -- reference Partial label access/mutation --
    
    const Partial & sourceReferencePartial( void ) const;
    
    Partial & sourceReferencePartial( void );
    
    const Partial & targetReferencePartial( void ) const;

    Partial & targetReferencePartial( void );
    
    void setSourceReferencePartial( const Partial & p = Partial() );
    
    void setSourceReferencePartial( const PartialList & partials, 
                                    Partial::label_type refLabel );
    
    void setTargetReferencePartial( const Partial & p = Partial() );

    void setTargetReferencePartial( const PartialList & partials, 
                                    Partial::label_type refLabel );
    
//  -- PartialList access --

    PartialList & partials( void ); 

    const PartialList & partials( void ) const; 

//  -- global morphing defaults and constants --

    static const double DefaultFixThreshold;

    static const double DefaultAmpShape;    

    static const double DefaultBreakpointGap;

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. 
    //  MorphingPair is a pair of pointers to Partials that are
    //  initialized to zero, and it is the element type for the
    //  PartialCorrespondence map.
    struct MorphingPair
    {
        Partial src;
        Partial tgt;    
    };
    typedef std::map< Partial::label_type, MorphingPair > PartialCorrespondence;
    
    void morph_aux( PartialCorrespondence & correspondence );
    
    //
    void appendMorphedSrc( Breakpoint srcBkpt, const Partial & tgtPartial, 
                           double time, Partial & newp  );
                           
    //
    void appendMorphedTgt( Breakpoint tgtBkpt, const Partial & srcPartial, 
                           double time, Partial & newp  );
                           
                           
        Breakpoint 
        interpolateParameters( const Breakpoint & srcBkpt, const Breakpoint & tgtBkpt,
                           double fweight, double aweight, double bweight ) const;

        double interpolateAmplitude( double srcAmp, double tgtAmp, double alpha ) const;
        double interpolateBandwidth( double srcBw, double tgtBw, double alpha ) const;
        double interpolateFrequency( double srcFreq, double tgtFreq, double alpha ) const;
        double interpolatePhase( double srcphase, double tgtphase, double alpha ) const;
        

        //      Recompute phases for a morphed Partial, so that the synthesized phases 
        //      match the source phases as closesly as possible at times when the 
        //      frequency morphing function is equal to 0 or 1. 
        void fixMorphedPhases( Partial & newp ) const;                           

};  //  end of class Morpher

}   //  end of namespace Loris

#endif /* ndef INCLUDE_MORPHER_H */

---