BPFTmplDec.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
 *
 */


#ifndef _BPFTmplDec_
#define _BPFTmplDec_

#include <iosfwd>

#include "PointTmpl.hxx" // for point functionality
#include "Err.hxx"//for Exception handling
#include "Array.hxx" // array functionality
#include "SearchArray.hxx" //array searches
#include "Enum.hxx"
#include "Component.hxx"
#include "GlobalEnums.hxx"

namespace CLAM
{
        class EInterpolation;

        template <class TX,class TY> class BPFTmpl:public Component
        {
                static const TData Infinity;

        public:
                BPFTmpl();

                BPFTmpl(const EInterpolation& eInterpolation);

                BPFTmpl(TSize size);

                BPFTmpl(TSize size,
                        const EInterpolation& eInterpolation);

                BPFTmpl(const BPFTmpl<TX,TY>& orig);

                void Init();

                const char * GetClassName() const {return "BPF";}

                TSize AllocatedSize(void) const {return mArray.AllocatedSize();}

                TSize Size(void) const {return mArray.Size();}

                void SetSize (TSize newSize){mArray.SetSize(newSize);}

                void Resize (TSize newSize){mArray.Resize(newSize);}

                TIndex Insert(const PointTmpl<TX,TY> &point);

                TIndex Insert(const TX &x,const TX &y);

                void DeleteIndex(TIndex index);

                void DeleteThroughXValue(const TX& x);

                void DeleteBetweenIndex(TIndex leftIndex,TIndex rightIndex);
        
                void DeleteBetweenXValues(const TX& leftX,const TX& rightX);

                void SetValue(TIndex index,const TY &y)
                {
                        mArray[index].SetY(y);
                        mIsSplineUpdated=false;
                }

                void SetXValue(TIndex index,const TX &x){
                        mArray[index].SetX(x);
                        mIsSplineUpdated=false;
                }

                void SetIntpType(const EInterpolation& eInterpolation);
                
                void SetStep(TSize step){mArray.SetStep(step);}
                TSize GetStep() {return mArray.GetStep();}

                TY GetValueFromIndex(TIndex index) const {
                        return mArray[index].GetY();
                }

                TY GetValue(const TX& x)        const {
                        return GetValue(x,meInterpolation);
                }

                TY GetValue (const TX& x,const EInterpolation& eInterpolation) const;

                const TX& GetXValue(TIndex index) const 
                {
                        return mArray[index].GetX();
                }

                TIndex GetPosition(const TX& x) const;


                void GetnClosest(TIndex foundIndex) const;

                BPFTmpl<TX, TY>& operator=(const BPFTmpl<TX, TY> &originalBPF);

                void UpdateSplineTable();

                void SetLeftDerivative(TData val);
                void UnsetLeftDerivative(void);
                void SetRightDerivative(TData val);
                void UnsetRightDerivative(void);
        
                const EInterpolation    &GetInterpolation() const {
                        return meInterpolation; 
                }

                Array<PointTmpl<TX,TY> > &GetPointArray() {
                        return mArray;
                }
                
protected:
        /*Member variables*/
                EInterpolation meInterpolation;
                TSize mnPoints;
                Array<PointTmpl<TX,TY> > mArray;
                SearchArray<PointTmpl<TX,TY> > mSearch;//search functionality for array
                mutable Array<TIndex> mClosestPoints;
                mutable Array<TY> mc,md;
                int mOrder; //interpolation order for polynomic interp.
                mutable TIndex mLastIndex; 
                mutable TX mLastX; 

                Array<TY> mSplineTable;
                bool mIsSplineUpdated;

                TData mLeftDerivative;

                TData mRightDerivative;
                
        TY BPFPolInt(const TX& x,const Array<TIndex>& closestPointsIndex,
                TData &errorEstimate) const;
        void CreateSplineTable();
        TY BPFSplineInt(const TX& x) const;
        void StoreOn(Storage & storage) const;
        void LoadFrom(Storage & storage);

        };

} // namespace CLAM

#endif // _BPFTmplDec_