SpectralPeakArray.hxx

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
 *                         UNIVERSITAT POMPEU FABRA
 *
 *
 * 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
 *
 */

// Class SpectralPeakArray: Processing Data class to store an array of spectral peaks
// Description:
//  This processing data class offers an interface for storing an array of spectral
//  peaks while maintaining efficient data access. This is accomplished by actually
//  storing in memory an independent buffer for each of the attributes of a spectral
//  peak. The interface to use SpectralPeak class is simulated adding an interface
//  that constructs these objects on the fly, whenever a Peak is accessed.
//  Furthermore, this class holds an array of indices that can be used for different
//  purposes such as sorting, assigning tracks...Any peak can be accessed throug its
//  actual position in the array or its associated index



#ifndef _SpectralPeakArray_
#define _SpectralPeakArray_

#include "DynamicType.hxx"
#include "Array.hxx"
#include "IndexArray.hxx"
#include "DataTypes.hxx"
#include "OSDefines.hxx"
#include "Err.hxx"
#include "ProcessingData.hxx"
#include "SpectralPeak.hxx"



namespace CLAM{


class SpectralPeakArray : public ProcessingData
{
public:
        DYNAMIC_TYPE_USING_INTERFACE (SpectralPeakArray, 8, ProcessingData);
        DYN_ATTRIBUTE (0, public, EScale, Scale);
        DYN_ATTRIBUTE (1, public, DataArray, MagBuffer);
        DYN_ATTRIBUTE (2, public, DataArray, FreqBuffer);
        DYN_ATTRIBUTE (3, public, DataArray, PhaseBuffer);
        DYN_ATTRIBUTE (4, public, DataArray, BinPosBuffer);
        DYN_ATTRIBUTE (5, public, DataArray, BinWidthBuffer);
        DYN_ATTRIBUTE (6, public, IndexArray, IndexArray);
        DYN_ATTRIBUTE (7, public, bool, MinimizeResizes);

protected:
        void DefaultInit();
public:

        SpectralPeakArray(const SpectralPeak& prototype);

        void InitFromPrototype(const SpectralPeak& spectralPeak);

        void InitPeak(SpectralPeak& spectralPeak) const;


        TData GetMag(TIndex pos) const{return GetMagBuffer()[pos];}
        TData GetFreq(TIndex pos)const{return GetFreqBuffer()[pos];}
        TData GetPhase(TIndex pos)const{return GetPhaseBuffer()[pos];}
        TData GetBinPos(TIndex pos)const{return GetBinPosBuffer()[pos];}
        int GetBinWidth(TIndex pos)const{return int(GetBinWidthBuffer()[pos]);}
        void SetMag(TIndex pos,TData newMag){GetMagBuffer()[pos]=newMag;}
        void SetFreq(TIndex pos,TData newFreq){GetFreqBuffer()[pos]=newFreq;}
        void SetPhase(TIndex pos,TData newPhase){GetPhaseBuffer()[pos]=newPhase;}
        void SetBinPos(TIndex pos,TData newBinPos){GetBinPosBuffer()[pos]=newBinPos;}
        void SetBinWidth(TIndex pos,int newBinWidth){GetBinWidthBuffer()[pos]=TData(newBinWidth);}

        TIndex GetMaxMagPos() const;

        TIndex GetMaxMagIndex() const;


        void InitSpectralPeak(SpectralPeak& spectralPeak) const;
        bool IsCorrectPrototype(const SpectralPeak& spectralPeak) const;
        SpectralPeak GetSpectralPeak(TIndex pos) const;
        SpectralPeak GetThruIndexSpectralPeak(TIndex pos) const;
        void SetSpectralPeak(TIndex pos,const SpectralPeak& spectralPeak,TIndex index=-1);
        void InsertSpectralPeak(TIndex pos,const SpectralPeak& spectralPeak,
                                                        bool insertIndex=false,TIndex index=-1);
        void AddSpectralPeak(const SpectralPeak& spectralPeak,bool addIndex=false,TIndex index=-1);
        void DeleteSpectralPeak(TIndex pos,bool deleteIndex=false);



/* index handling */

        int GetnIndexedPeaks() const;

        TIndex GetPositionFromIndex(TIndex index) const;

        void SetIndex(TIndex pos,TIndex index){GetIndexArray()[pos]=index;};
        TIndex GetIndex(TIndex pos) const {return GetIndexArray()[pos];}
        void DeleteIndex (TIndex index);
        void ResetIndices();
        void InitIndices();
        void SetIndicesTo(TIndex val);
        void AddIndex(TIndex index);

        TIndex GetFirstNonValidIndexPosition(TIndex beginAt) const;
        bool IsValidIndex(TIndex position) const;
        TIndex IsIndexExisting(TIndex index) const;
        TIndex GetMaxIndex() const;

/* Peak Array size handling*/

        TSize GetnPeaks() const
        {
                if(HasMagBuffer()) return GetMagBuffer().Size();
                if(HasFreqBuffer()) return GetFreqBuffer().Size();
                if(HasPhaseBuffer()) return GetPhaseBuffer().Size();
                if(HasBinPosBuffer()) return GetBinPosBuffer().Size();
                if(HasBinWidthBuffer()) return GetBinWidthBuffer().Size();
                else return 0;
        }

// I think we need the Resize() as well. It does not hurt at least. - Yushen Han

        void SetnPeaks(TSize npeaks)
        {
                if (npeaks>GetnMaxPeaks()) SetnMaxPeaks(npeaks);
                if(HasMagBuffer()) {
                        GetMagBuffer().Resize(npeaks);
                        GetMagBuffer().SetSize(npeaks);}
                if(HasFreqBuffer()) {
                        GetFreqBuffer().Resize(npeaks);
                        GetFreqBuffer().SetSize(npeaks);}
                if(HasPhaseBuffer()){
                        GetPhaseBuffer().Resize(npeaks);
                        GetPhaseBuffer().SetSize(npeaks);}
                if(HasBinPosBuffer()) {
                        GetBinPosBuffer().Resize(npeaks);
                        GetBinPosBuffer().SetSize(npeaks);}
                if(HasBinWidthBuffer()) {
                        GetBinWidthBuffer().Resize(npeaks);
                        GetBinWidthBuffer().SetSize(npeaks);}
                if(HasIndexArray()) {
                        GetIndexArray().Resize(npeaks);
                        GetIndexArray().SetSize(npeaks);}


        }

        void SetnMaxPeaks(TSize npeaks)
        {
                if(HasMagBuffer()){
                        GetMagBuffer().Resize(npeaks);
                        if(GetMinimizeResizes())
                                GetMagBuffer().SetStep(npeaks);}
                if(HasFreqBuffer()){
                        GetFreqBuffer().Resize(npeaks);
                        if(GetMinimizeResizes())
                                GetFreqBuffer().SetStep(npeaks);}
                if(HasPhaseBuffer()){
                        GetPhaseBuffer().Resize(npeaks);
                        if(GetMinimizeResizes())
                                GetPhaseBuffer().SetStep(npeaks);}
                if(HasBinPosBuffer()){
                        GetBinPosBuffer().Resize(npeaks);
                        if(GetMinimizeResizes())
                                GetBinPosBuffer().SetStep(npeaks);}
                if(HasBinWidthBuffer()){
                        GetBinWidthBuffer().Resize(npeaks);
                        if(GetMinimizeResizes())
                                GetBinWidthBuffer().SetStep(npeaks);}
                if(HasIndexArray()){
                        GetIndexArray().Resize(npeaks);
                        if(GetMinimizeResizes())
                                GetIndexArray().SetStep(npeaks);}
        }

        TSize GetnMaxPeaks() const
        {
                if(HasMagBuffer()) return GetMagBuffer().AllocatedSize();
                if(HasFreqBuffer()) return GetFreqBuffer().AllocatedSize();
                if(HasPhaseBuffer()) return GetPhaseBuffer().AllocatedSize();
                if(HasBinPosBuffer()) return GetBinPosBuffer().AllocatedSize();
                if(HasBinWidthBuffer()) return GetBinWidthBuffer().AllocatedSize();
                else return 0;
        }

        //index getters and setters
        double GetThruIndexFreq(TIndex pos) const;
        double GetThruIndexMag(TIndex pos) const;
        double GetThruIndexPhase(TIndex pos) const;
        double GetThruIndexBinPos(TIndex pos) const;
        TSize  GetThruIndexBinWidth(TIndex pos) const;
        void   SetThruIndexFreq(TIndex pos,double freq);
        void   SetThruIndexMag(TIndex pos,double mag) ;
        void   SetThruIndexPhase(TIndex pos,double phase) ;
        void   SetThruIndexBinPos(TIndex pos,double binPos);
        void   SetThruIndexBinWidth(TIndex pos,TSize binWidth);
        void   SetThruIndexSpectralPeak(TIndex pos,SpectralPeak& peak);

        void SetIsIndexUpToDate(bool isUpToDate)
        {
                mIsIndexUpToDate = isUpToDate;
        }

        void TodB();
        void ToLinear();

        void CopyMembers(SpectralPeakArray& sourceSpectralPeakArray);

        SpectralPeakArray operator+(const SpectralPeakArray& in);
private:
        bool mIsIndexUpToDate;

};

}; // namespace CLAM

#endif