CLAM: SpectrumInterpolator.cxx Source File

00001 /*
00002  * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
00003  *                         UNIVERSITAT POMPEU FABRA
00004  *
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019  *
00020  */
00021 
00022 #include "Complex.hxx"
00023 #include "SpecTypeFlags.hxx"
00024 #include "SpectrumInterpolator.hxx"
00025 #include "BPF.hxx"
00026 #include "Point.hxx"
00027 
00028 namespace CLAM {
00029 
00030         void SpecInterpConfig::DefaultInit()
00031         {
00032                 AddAll();
00033                 UpdateData();
00034         }
00035 
00036 
00037         SpectrumInterpolator::SpectrumInterpolator()
00038                 : mSize(0),
00039                   mIn1("Input 1",this),
00040                   mIn2("Input 2",this),
00041                   mOut("Output",this),
00042                   mProtoState(SOther),
00043                   mInterpolationFactorCtl("InterpolationFactor",this)
00044         {
00045                 Configure(SpecInterpConfig());
00046         }
00047 
00048         SpectrumInterpolator::SpectrumInterpolator(const SpecInterpConfig &c)
00049                 : mSize(0),
00050                   mIn1("Input 1",this),
00051                   mIn2("Input 2",this),
00052                   mOut("Output",this),
00053                   mProtoState(SOther),
00054                   mInterpolationFactorCtl("InterpolationFactor",this)
00055         {
00056                 Configure(c);
00057         }
00058 
00059         bool SpectrumInterpolator::ConcreteConfigure(const ProcessingConfig&c)
00060         {
00061                 CopyAsConcreteConfig(mConfig, c);
00062                 //Initialize interpolation factor control from value in the configuration
00063                 mInterpolationFactorCtl.DoControl(mConfig.GetInterpolationFactor());
00064 
00065                 return true;
00066         }
00067 
00068         // Unsupervised Do() function.
00069 //      TODO use 'const Spectrum& in1, const Spectrum& in2' and spread it to the rest
00070         bool SpectrumInterpolator::Do(Spectrum& in1, Spectrum& in2, Spectrum& out)
00071         {
00072                 CLAM_DEBUG_ASSERT(IsRunning(),
00073                                   "SpectrumInterpolator::Do(): Not in execution mode");
00074 
00075                 switch (mProtoState) {
00076                 // Fast prototype configurations
00077                 case SMagPhase:
00078                         InterpolateMagPhase(in1,in2,out);
00079                         break;
00080                 case SComplex:
00081                         InterpolateComplex(in1,in2,out);
00082                         break;
00083                 case SPolar:
00084                         InterpolatePolar(in1,in2,out);
00085                         break;
00086                 case SBPF:
00087                         InterpolateBPF(in1,in2,out);
00088                         break;
00089                 case SBPFMagPhase:
00090                         InterpolateBPFMagPhase(in1,in2,out);
00091                         break;
00092                 case SBPFComplex:
00093                         InterpolateBPFComplex(in1,in2,out);
00094                         break;
00095                 case SBPFPolar:
00096                         InterpolateBPFPolar(in1,in2,out);
00097                         break;
00098                 case SMagPhaseBPF:
00099                         InterpolateMagPhaseBPF(in1,in2,out);
00100                         break;
00101                 case SComplexBPF:
00102                         InterpolateComplexBPF(in1,in2,out);
00103                         break;
00104                 case SPolarBPF:
00105                         InterpolatePolarBPF(in1,in2,out);
00106                         break;
00107                 // Slow type configurations
00108                 case SOther:
00109                         Interpolate(in1,in2,out);
00110                         break;
00111                 default:
00112                         CLAM_ASSERT(false,"Do(...) : internal inconsistency (invalid mProtoState)");
00113                 }
00114 
00115                 return true;
00116         }
00117 
00118         bool SpectrumInterpolator::Do(void)
00119         {
00120                 CLAM_ASSERT(false, "SpectrumInterpolator::Do(): Not implemented");
00121 
00122                 return true;
00123         }
00124 
00125         // This function analyses the inputs and decides which prototypes to use 
00126         // For the interpolation computation. 
00127         bool SpectrumInterpolator::SetPrototypes(const Spectrum& in1,const Spectrum& in2,const Spectrum& out)
00128         {
00129                 // Check common attributes
00130                 SpecTypeFlags t1;
00131                 in1.GetType(t1);
00132                 SpecTypeFlags t2;
00133                 in2.GetType(t2);
00134                 SpecTypeFlags to;
00135                 out.GetType(to);
00136 
00137                 // Sanity check:
00138                 CLAM_ASSERT((t1.bMagPhase || t1.bComplex || t1.bPolar || t1.bMagPhaseBPF),
00139                                 "SpectrumInterpolator: First spectrum has no content");
00140                 CLAM_ASSERT((t2.bMagPhase || t2.bComplex || t2.bPolar || t2.bMagPhaseBPF),
00141                                 "SpectrumInterpolator: Second spectrum has no content");
00142                 CLAM_ASSERT((to.bMagPhase || to.bComplex || to.bPolar || to.bMagPhaseBPF),
00143                                 "SpectrumInterpolator: Output spectrum has no content");
00144 
00145                 // Interpolateer size. "pure" BPFs are not considered here.
00146                 mSize = 0;
00147                 if (t1.bMagPhase || t1.bComplex || t1.bPolar) {
00148                         mSize = in1.GetSize();
00149                         CLAM_ASSERT(mSize,"SpectrumInterpolator::SetPrototypes: Zero size spectrum");
00150                 }
00151                 if (t2.bMagPhase || t2.bComplex || t2.bPolar)
00152                         if (mSize) {
00153                                 CLAM_ASSERT(mSize == in2.GetSize(),"SpectrumInterpolator::SetPrototypes:Size mismatch in spectrum interpolation");
00154                         }
00155                         else {
00156                                 mSize = in2.GetSize();
00157                                 CLAM_ASSERT(mSize,"SpectrumInterpolator::SetPrototypes: Zero size spectrum");
00158                         }
00159                 if (to.bMagPhase || to.bComplex || to.bPolar)
00160                         if (mSize) {
00161                                 CLAM_ASSERT(mSize == out.GetSize(),"SpectrumInterpolator::SetPrototypes:Size mismatch in spectrum interpolation");
00162                         }
00163                         else {
00164                                 mSize = out.GetSize();
00165                                 CLAM_ASSERT(mSize,"SpectrumInterpolator::SetPrototypes: Zero size spectrum");
00166                         }
00167 
00168                 // Spectral Range.  
00169                 // We could also ignore BPF-only objects here, but in
00170                 // practice, if a BPF is designed for a certain spectral
00171                 // range, error will probably be too big out of the range, out
00172                 // we always force range matching
00173                 CLAM_ASSERT(in1.GetSpectralRange() == in2.GetSpectralRange() &&
00174                         in1.GetSpectralRange() == out.GetSpectralRange() ,"SpectrumInterpolator::SetPrototypes: Spectral range mismatch in spectrum interpolation");
00175 
00176                 // Scale.
00177                 if (in1.GetScale() == EScale::eLinear)
00178                         if (in2.GetScale() == EScale::eLinear)
00179                                 mScaleState=Slinlin;
00180                         else
00181                                 mScaleState=Slinlog;
00182                 else
00183                         if (in2.GetScale() == EScale::eLinear)
00184                                 mScaleState=Sloglin;
00185                         else
00186                                 mScaleState=Sloglog;
00187                 // Log scale output might be useful, for example when working
00188                 // with BPF objects at the three ports. But right for now...
00189                 CLAM_ASSERT(out.GetScale() != EScale::eLog,"SpectrumInterpolator: Log Scale Output not implemented");
00190 
00191                 // Prototypes.
00192 
00193                 // BPF Interpolation.
00194                 bool i1BPF=false, i2BPF=false, oBPF=false;
00195                 if (t1.bMagPhaseBPF && !t1.bComplex && !t1.bPolar && !t1.bMagPhase)
00196                         i1BPF=true;
00197                 if (t2.bMagPhaseBPF && !t2.bComplex && !t2.bPolar && !t2.bMagPhase)
00198                         i2BPF=true;
00199                 if (to.bMagPhaseBPF && !to.bComplex && !to.bPolar && !to.bMagPhase)
00200                         oBPF=true;
00201 
00202                 if (oBPF) {
00203                         // BPF output requires interpolating the inputs.
00204                         mProtoState=SBPF;
00205                         return true;
00206                 }
00207                 if (i1BPF) {
00208                         // States with direct BPF implementation.
00209                         if (t2.bMagPhase && to.bMagPhase) {
00210                                 mProtoState=SBPFMagPhase;
00211                                 return true;
00212                         }
00213                         if (t2.bComplex && to.bComplex) {
00214                                 mProtoState=SBPFComplex;
00215                                 return true;
00216                         }
00217                         if (t2.bPolar && to.bPolar) {
00218                                 mProtoState=SBPFPolar;
00219                                 return true;
00220                         }
00221                         // States requiring 1 conversion:
00222                         if (t2.bMagPhase || to.bMagPhase) {
00223                                 mProtoState=SBPFMagPhase;
00224                                 return true;
00225                         }
00226                         if (t2.bComplex || to.bComplex) {
00227                                 mProtoState=SBPFComplex;
00228                                 return true;
00229                         }
00230                         if (t2.bPolar  || to.bPolar) {
00231                                 mProtoState=SBPFPolar;
00232                                 return true;
00233                         }
00234                         // Should never get here:
00235                         CLAM_ASSERT(false, 
00236                                 "SpectrumInterpolator::SetPrototypes: Data flags internal inconsistency");
00237                 }
00238                 if (i2BPF) {
00239                         // States with direct BPF implementation.
00240                         if (t1.bMagPhase && to.bMagPhase) {
00241                                 mProtoState=SMagPhaseBPF;
00242                                 return true;
00243                         }
00244                         if (t1.bComplex && to.bComplex) {
00245                                 mProtoState=SComplexBPF;
00246                                 return true;
00247                         }
00248                         if (t1.bPolar && to.bPolar) {
00249                                 mProtoState=SPolarBPF;
00250                                 return true;
00251                         }
00252                         // States requiring 1 conversion:
00253                         if (t1.bMagPhase || to.bMagPhase) {
00254                                 mProtoState=SMagPhaseBPF;
00255                                 return true;
00256                         }
00257                         if (t1.bComplex || to.bComplex) {
00258                                 mProtoState=SComplexBPF;
00259                                 return true;
00260                         }
00261                         if (t1.bPolar || to.bPolar) {
00262                                 mProtoState=SPolarBPF;
00263                                 return true;
00264                         }
00265                         // Should never get here:
00266                         CLAM_ASSERT(false, 
00267                                 "SpectrumInterpolator::SetPrototypes:"
00268                                 " invalid data flags");
00269                 }
00270                 // Direct non-BPF states.
00271                 if (t1.bMagPhase && t2.bMagPhase &&     to.bMagPhase) {
00272                         mProtoState=SMagPhase;
00273                         return true;
00274                 }
00275                 if (t1.bComplex && t2.bComplex && to.bComplex) {
00276                         mProtoState=SComplex;
00277                         return true;
00278                 }
00279                 if (t1.bPolar && t2.bPolar && to.bPolar) {
00280                         mProtoState=SPolar;
00281                         return true;
00282                 }
00283                 // States Requiring 1 Conversion
00284                 if ( (t1.bMagPhase && t2.bMagPhase) ||
00285                          (t1.bMagPhase && to.bMagPhase) ||
00286                          (t2.bMagPhase && to.bMagPhase)) {
00287                         mProtoState=SMagPhase;
00288                         return true;
00289                 }
00290                 if ( (t1.bComplex && t2.bComplex) ||
00291                          (t1.bComplex && to.bComplex) ||
00292                          (t2.bComplex && to.bComplex)) {
00293                         mProtoState=SComplex;
00294                         return true;
00295                 }
00296                 if ( (t1.bPolar && t2.bPolar) ||
00297                          (t1.bPolar && to.bPolar) ||
00298                          (t2.bPolar && to.bPolar)) {
00299                         mProtoState=SPolar;
00300                         return true;
00301                 }
00302                 // Bad luck. We require 2 conversions...
00303                 mProtoState=SMagPhase;
00304                 return true;
00305         }
00306 
00307 
00308         bool SpectrumInterpolator::SetPrototypes()
00309         {
00310                 CLAM_ASSERT(false, "SpectrumInterpolator::SetPrototypes(): Not implemented");
00311 
00312                 return true;
00313         }
00314 
00315         bool SpectrumInterpolator::UnsetPrototypes()
00316         {
00317                 mProtoState=SOther;
00318                 return true;
00319         }
00320 
00321 
00322         void SpectrumInterpolator::Interpolate(Spectrum& in1, Spectrum& in2, Spectrum& out)
00323         {
00324                 PrototypeState state_copy = mProtoState;
00325                 ScaleState state2_copy = mScaleState;
00326 
00327                 SetPrototypes(in1,in2,out);
00328                 Do(in1,in2,out);
00329                 
00330                 mProtoState = state_copy;
00331                 mScaleState = state2_copy;
00332         }
00333 
00334 
00335         void SpectrumInterpolator::InterpolateMagPhase(Spectrum& in1, Spectrum& in2, Spectrum& out)
00336         {
00337                 switch(mScaleState) {
00338                 case Slinlin:
00339                         InterpolateMagPhaseLin(in1,in2,out);
00340                         break;
00341                 case Sloglog:
00342                         InterpolateMagPhaseLog(in1,in2,out);
00343                         break;
00344                 case Slinlog:
00345                         InterpolateMagPhaseLinLog(in1,in2,out);
00346                         break;
00347                 case Sloglin:
00348                         InterpolateMagPhaseLinLog(in2,in1,out);
00349                         break;
00350                 }
00351         }
00352 
00353         void SpectrumInterpolator::InterpolateMagPhaseLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00354         {
00355                 bool remove1=false,remove2=false,remove3=false;
00356                 SpecTypeFlags f;
00357 
00358                 // This function was choosed because some of the data objects had
00359                 // their MagPhase attribute instantiated. We don't know which of
00360                 // them, though, out we must check and instantiate the attribute
00361                 // it it is missed. This could be optimised out by Interpolateing more
00362                 // States, see coments on this in the class declaration.
00363                 in1.GetType(f);
00364                 if (!f.bMagPhase) {
00365                         remove1=true;
00366                         f.bMagPhase=true;
00367                         in1.SetTypeSynchronize(f);
00368                 }
00369                 in2.GetType(f);
00370                 if (!f.bMagPhase) {
00371                         remove2=true;
00372                         f.bMagPhase=true;
00373                         in2.SetTypeSynchronize(f);
00374                 }
00375                 out.GetType(f);
00376                 if (!f.bMagPhase) {
00377                         remove3=true;
00378                         f.bMagPhase=true;
00379                         out.SetType(f);
00380                 }
00381 
00382                 TData *m1 = in1.GetMagBuffer().GetPtr();
00383                 TData *f1 = in1.GetPhaseBuffer().GetPtr();
00384                 TData *m2 = in2.GetMagBuffer().GetPtr();
00385                 TData *f2 = in2.GetPhaseBuffer().GetPtr();
00386                 TData *mo = out.GetMagBuffer().GetPtr();
00387                 TData *fo = out.GetPhaseBuffer().GetPtr();
00388 /*****************************/
00389 //OPERATION: MAGPHASE AND MAGPHASE              
00390                 
00391                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00392                 if(intFactor>1) intFactor=1;
00393                 if(intFactor<0) intFactor=0;
00394                 TData invIntFactor=1-intFactor;
00395 
00396                 Polar polInvIntFactor=Polar(invIntFactor);
00397                 Polar polIntFactor=Polar(intFactor);
00398 
00399                 for (int i=0;i<mSize;i++) {
00400                         Polar po=polInvIntFactor*Polar(m1[i],f1[i])+polIntFactor*Polar(m2[i],f2[i]);
00401                         mo[i]=po.Mag();
00402                         fo[i]=po.Ang();
00403                 }
00404 
00405                 f.bComplex=f.bPolar=f.bMagPhaseBPF=false;
00406                 f.bMagPhase=true;
00407                 out.SynchronizeTo(f);
00408 
00409                 if (remove1) {
00410                         in1.RemoveMagBuffer();
00411                         in1.RemovePhaseBuffer();
00412                         in1.UpdateData();
00413                 }
00414                 if (remove2) {
00415                         in2.RemoveMagBuffer();
00416                         in2.RemovePhaseBuffer();
00417                         in2.UpdateData();
00418                 }
00419                 if (remove3) {
00420                         out.RemoveMagBuffer();
00421                         out.RemovePhaseBuffer();
00422                         out.UpdateData();
00423                 }
00424 
00425         }
00426 
00427         void SpectrumInterpolator::InterpolateComplex(Spectrum& in1, Spectrum& in2, Spectrum& out)
00428         {
00429                 switch(mScaleState) {
00430                 case Slinlin:
00431                         InterpolateComplexLin(in1,in2,out);
00432                         break;
00433                 case Sloglog:
00434                         InterpolateComplexLog(in1,in2,out);
00435                         break;
00436                 case Slinlog:
00437                         InterpolateComplexLinLog(in1,in2,out);
00438                         break;
00439                 case Sloglin:
00440                         InterpolateComplexLinLog(in2,in1,out);
00441                         break;
00442                 }
00443         }
00444 
00445         void SpectrumInterpolator::InterpolateComplexLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00446         {
00447                 bool remove1=false,remove2=false,remove3=false;
00448                 SpecTypeFlags f;
00449                 
00450                 // This function was choosed because some of the data objects had
00451                 // their Complex attribute instantiated. We don't know which of
00452                 // them, though, out we must check and instantiate the attribute
00453                 // it it is missed. This could be optimised out by Interpolateing more
00454                 // States, see coments on this in the class declaration.
00455                 in1.GetType(f);
00456                 if (!f.bComplex) {
00457                         remove1=true;
00458                         f.bComplex=true;
00459                         in1.SetTypeSynchronize(f);
00460                 }
00461                 in2.GetType(f);
00462                 if (!f.bComplex) {
00463                         remove2=true;
00464                         f.bComplex=true;
00465                         in2.SetTypeSynchronize(f);
00466                 }
00467                 out.GetType(f);
00468                 if (!f.bComplex) {
00469                         remove3=true;
00470                         f.bComplex=true;
00471                         out.SetType(f);
00472                 }
00473 
00474                 Complex *c1 = in1.GetComplexArray().GetPtr();
00475                 Complex *c2 = in2.GetComplexArray().GetPtr();
00476                 Complex *co = out.GetComplexArray().GetPtr();
00477 /*****************************/
00478 //OPERATION: COMPLEX AND COMPLEX
00479                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00480                 if(intFactor>1) intFactor=1;
00481                 if(intFactor<0) intFactor=0;
00482                 TData invIntFactor=1-intFactor;
00483 
00484                 for (int i=0;i<mSize;i++)
00485                         co[i]=c1[i]*invIntFactor+c2[i]*intFactor;
00486 
00487                 f.bMagPhase=f.bPolar=f.bMagPhaseBPF=false;
00488                 f.bComplex=true;
00489                 out.SynchronizeTo(f);
00490 
00491                 if (remove1) {
00492                         in1.RemoveComplexArray();
00493                         in1.UpdateData();
00494                 }
00495                 if (remove2) {
00496                         in2.RemoveComplexArray();
00497                         in2.UpdateData();
00498                 }
00499                 if (remove3) {
00500                         out.RemoveComplexArray();
00501                         out.UpdateData();
00502                 }
00503         }
00504 
00505 
00506         void SpectrumInterpolator::InterpolatePolar(Spectrum& in1, Spectrum& in2, Spectrum& out)
00507         {
00508                 switch(mScaleState) {
00509                 case Slinlin:
00510                         InterpolatePolarLin(in1,in2,out);
00511                         break;
00512                 case Sloglog:
00513                         InterpolatePolarLog(in1,in2,out);
00514                         break;
00515                 case Slinlog:
00516                         InterpolatePolarLinLog(in1,in2,out);
00517                         break;
00518                 case Sloglin:
00519                         InterpolatePolarLinLog(in2,in1,out);
00520                         break;
00521                 }
00522         }
00523 
00524         void SpectrumInterpolator::InterpolatePolarLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00525         {
00526                 bool remove1=false,remove2=false,remove3=false;
00527                 SpecTypeFlags f;
00528                 
00529                 // This function was choosed because some of the data objects had
00530                 // their Polar attribute instantiated. We don't know which of
00531                 // them, though, out we must check and instantiate the attribute
00532                 // it it is missed. This could be optimised out by Interpolateing more
00533                 // States, see coments on this in the class declaration.
00534                 in1.GetType(f);
00535                 if (!f.bPolar) {
00536                         remove1=true;
00537                         f.bPolar=true;
00538                         in1.SetTypeSynchronize(f);
00539                 }
00540                 in2.GetType(f);
00541                 if (!f.bPolar) {
00542                         remove2=true;
00543                         f.bPolar=true;
00544                         in2.SetTypeSynchronize(f);
00545                 }
00546                 out.GetType(f);
00547                 if (!f.bPolar) {
00548                         remove3=true;
00549                         f.bPolar=true;
00550                         out.SetType(f);
00551                 }
00552 
00553                 Polar *p1 = in1.GetPolarArray().GetPtr();
00554                 Polar *p2 = in2.GetPolarArray().GetPtr();
00555                 Polar *po = out.GetPolarArray().GetPtr();
00556 /*****************************/
00557 //OPERATION: POLAR AND POLAR
00558                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00559                 if(intFactor>1) intFactor=1;
00560                 if(intFactor<0) intFactor=0;
00561                 TData invIntFactor=1-intFactor;
00562 
00563                 Polar polInvIntFactor=Polar(invIntFactor);
00564                 Polar polIntFactor=Polar(intFactor);
00565 
00566                 for (int i=0;i<mSize;i++)
00567                         po[i]=polInvIntFactor*p1[i]+polIntFactor*p2[i];
00568 
00569                 f.bComplex=f.bMagPhase=f.bMagPhaseBPF=false;
00570                 f.bPolar=true;
00571                 out.SynchronizeTo(f);
00572 
00573                 if (remove1) {
00574                         in1.RemovePolarArray();
00575                         in1.UpdateData();
00576                 }
00577                 if (remove2) {
00578                         in2.RemovePolarArray();
00579                         in2.UpdateData();
00580                 }
00581                 if (remove3) {
00582                         out.RemovePolarArray();
00583                         out.UpdateData();
00584                 }
00585         }
00586 
00587 
00588         void SpectrumInterpolator::InterpolateBPFMagPhase(Spectrum& in1, Spectrum& in2, Spectrum& out)
00589         {
00590                 switch(mScaleState) {
00591                 case Slinlin:
00592                         InterpolateBPFMagPhaseLin(in1,in2,out);
00593                         break;
00594                 case Sloglog:
00595                         InterpolateBPFMagPhaseLog(in1,in2,out);
00596                         break;
00597                 case Slinlog:
00598                         CLAM_ASSERT(false,"InterpolateBPFMagPhaseLinLog: Not implemented");
00599                         break;
00600                 case Sloglin:
00601                         InterpolateBPFMagPhaseLogLin(in1,in2,out);
00602                         break;
00603                 }
00604         }
00605 
00606         void SpectrumInterpolator::InterpolateMagPhaseBPF(Spectrum& in1, Spectrum& in2, Spectrum& out)
00607         {
00608                 switch(mScaleState) {
00609                 case Slinlin:
00610                         InterpolateBPFMagPhaseLin(in2,in1,out);
00611                         break;
00612                 case Sloglog:
00613                         InterpolateBPFMagPhaseLog(in2,in1,out);
00614                         break;
00615                 case Slinlog:
00616                         InterpolateBPFMagPhaseLogLin(in2,in1,out);
00617                         break;
00618                 case Sloglin:
00619                         CLAM_ASSERT(false,"InterpolateBPFMagPhaseLinLog: Not implemented");
00620                         break;
00621                 }
00622         }
00623 
00624         void SpectrumInterpolator::InterpolateBPFMagPhaseLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00625         {
00626                 bool remove2=false,remove3=false;
00627                 SpecTypeFlags f;
00628 
00629                 // This function was choosed because in1 is a BPF Spectrum,
00630                 // and some of the non-BPF data objects have their MagPhase
00631                 // attribute instantiated. We don't know which of them,
00632                 // though, out we must check and instantiate the attribute it
00633                 // it is missed. This could be optimised out by Interpolateing more
00634                 // States, see coments on this in the class declaration.
00635                 in2.GetType(f);
00636                 if (!f.bMagPhase) {
00637                         remove2=true;
00638                         f.bMagPhase=true;
00639                         in2.SetTypeSynchronize(f);
00640                 }
00641                 out.GetType(f);
00642                 if (!f.bMagPhase) {
00643                         remove3=true;
00644                         f.bMagPhase=true;
00645                         out.SetType(f);
00646                 }
00647 
00648                 TData pos = 0.0;
00649                 TData delta = out.GetSpectralRange() / 
00650                               ((TData)out.GetSize()-TData(1.0));
00651                 BPF &m1 = in1.GetMagBPF();
00652                 BPF &f1 = in1.GetPhaseBPF();
00653                 TData *m2 = in2.GetMagBuffer().GetPtr();
00654                 TData *f2 = in2.GetPhaseBuffer().GetPtr();
00655                 TData *mo = out.GetMagBuffer().GetPtr();
00656                 TData *fo = out.GetPhaseBuffer().GetPtr();
00657 /*****************************/
00658 //OPERATION: BPF AND MAGPHASE
00659                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00660                 if(intFactor>1) intFactor=1;
00661                 if(intFactor<0) intFactor=0;
00662                 TData invIntFactor=1-intFactor;
00663 
00664                 Polar polInvIntFactor=Polar(invIntFactor);
00665                 Polar polIntFactor=Polar(intFactor);
00666 
00667                 for (int i=0;i<mSize;i++) {
00668                         Polar po = polInvIntFactor*Polar(m1.GetValue(pos),f1.GetValue(pos)) + 
00669                                     polIntFactor*Polar(m2[i],f2[i]);
00670                         mo[i]=po.Mag();
00671                         fo[i]=po.Ang();
00672                         pos+=delta;
00673                 }
00674 
00675                 f.bComplex=f.bPolar=f.bMagPhaseBPF=false;
00676                 f.bMagPhase=true;
00677                 out.SynchronizeTo(f);
00678                 
00679                 if (remove2) {
00680                         in2.RemoveMagBuffer();
00681                         in2.RemovePhaseBuffer();
00682                         in2.UpdateData();
00683                 }
00684                 if (remove3) {
00685                         out.RemoveMagBuffer();
00686                         out.RemovePhaseBuffer();
00687                         out.UpdateData();
00688                 }
00689         }
00690 
00691         void SpectrumInterpolator::InterpolateBPFMagPhaseLogLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00692         {
00693                 bool remove2=false,remove3=false;
00694                 SpecTypeFlags f;
00695 
00696                 // This function was choosed because in1 is a BPF Spectrum,
00697                 // and some of the non-BPF data objects have their MagPhase
00698                 // attribute instantiated. We don't know which of them,
00699                 // though, out we must check and instantiate the attribute it
00700                 // it is missed. This could be optimised out by Interpolateing more
00701                 // States, see coments on this in the class declaration.
00702                 in2.GetType(f);
00703                 if (!f.bMagPhase) {
00704                         remove2=true;
00705                         f.bMagPhase=true;
00706                         in2.SetTypeSynchronize(f);
00707                 }
00708                 out.GetType(f);
00709                 if (!f.bMagPhase) {
00710                         remove3=true;
00711                         f.bMagPhase=true;
00712                         out.SetType(f);
00713                 }
00714 
00715                 TData pos = 0.0;
00716                 TData delta = out.GetSpectralRange() / 
00717                               ((TData)out.GetSize()-TData(1.0));
00718                 BPF &m1 = in1.GetMagBPF();
00719                 BPF &f1 = in1.GetPhaseBPF();
00720                 TData *m2 = in2.GetMagBuffer().GetPtr();
00721                 TData *f2 = in2.GetPhaseBuffer().GetPtr();
00722                 TData *mo = out.GetMagBuffer().GetPtr();
00723                 TData *fo = out.GetPhaseBuffer().GetPtr();
00724 /*****************************/
00725 //OPERATION: BPF(LOG) AND MAGPHASE
00726                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00727                 if(intFactor>1) intFactor=1;
00728                 if(intFactor<0) intFactor=0;
00729                 TData invIntFactor=1-intFactor;
00730                 Polar polInvIntFactor=Polar(invIntFactor);
00731                 Polar polIntFactor=Polar(intFactor);
00732                 
00733                 for (int i=0;i<mSize;i++) {
00734                         Polar po = polInvIntFactor*Polar(CLAM_pow(TData(10),m1.GetValue(pos)/TData(10.0)),f1.GetValue(pos)) + 
00735                                     polIntFactor*Polar(m2[i],f2[i]);
00736                         mo[i]=po.Mag();
00737                         fo[i]=po.Ang();
00738                         pos+=delta;
00739                 }
00740 
00741                 f.bComplex=f.bPolar=f.bMagPhaseBPF=false;
00742                 f.bMagPhase=true;
00743                 out.SynchronizeTo(f);
00744                 
00745                 if (remove2) {
00746                         in2.RemoveMagBuffer();
00747                         in2.RemovePhaseBuffer();
00748                         in2.UpdateData();
00749                 }
00750                 if (remove3) {
00751                         out.RemoveMagBuffer();
00752                         out.RemovePhaseBuffer();
00753                         out.UpdateData();
00754                 }
00755         }
00756 
00757         void SpectrumInterpolator::InterpolateBPFComplex(Spectrum& in1, Spectrum& in2, Spectrum& out)
00758         {
00759                 switch(mScaleState) {
00760                 case Slinlin:
00761                         InterpolateBPFComplexLin(in1,in2,out);
00762                         break;
00763                 case Sloglog:
00764                         InterpolateBPFComplexLog(in1,in2,out);
00765                         break;
00766                 case Slinlog:
00767                         CLAM_ASSERT(false,"InterpolateBPFMagPhaseLinLog: Not implemented");
00768                         break;
00769                 case Sloglin:
00770                         InterpolateBPFComplexLogLin(in1,in2,out);
00771                         break;
00772                 }
00773         }
00774 
00775         void SpectrumInterpolator::InterpolateComplexBPF(Spectrum& in1, Spectrum& in2, Spectrum& out)
00776         {
00777                 switch(mScaleState) {
00778                 case Slinlin:
00779                         InterpolateBPFComplexLin(in2,in1,out);
00780                         break;
00781                 case Sloglog:
00782                         InterpolateBPFComplexLog(in2,in1,out);
00783                         break;
00784                 case Slinlog:
00785                         InterpolateBPFComplexLogLin(in2,in1,out);
00786                         break;
00787                 case Sloglin:
00788                         CLAM_ASSERT(false,"InterpolateBPFMagPhaseLinLog: Not implemented");
00789                         break;
00790                 }
00791         }
00792 
00793         void SpectrumInterpolator::InterpolateBPFComplexLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00794         {
00795                 bool remove2=false,remove3=false;
00796                 SpecTypeFlags f;
00797 
00798                 // This function was choosed because in1 is a BPF Spectrum,
00799                 // and some of the non-BPF data objects have their Complex
00800                 // attribute instantiated. We don't know which of them,
00801                 // though, out we must check and instantiate the attribute it
00802                 // it is missed. This could be optimised out by Interpolateing more
00803                 // States, see coments on this in the class declaration.
00804                 in2.GetType(f);
00805                 if (!f.bComplex) {
00806                         remove2=true;
00807                         f.bComplex=true;
00808                         in2.SetTypeSynchronize(f);
00809                 }
00810                 out.GetType(f);
00811                 if (!f.bComplex) {
00812                         remove3=true;
00813                         f.bComplex=true;
00814                         out.SetType(f);
00815                 }
00816 
00817                 TData pos = 0.0;
00818                 TData delta = out.GetSpectralRange() / 
00819                               ((TData)out.GetSize()-TData(1.0));
00820                 BPF &m1 = in1.GetMagBPF();
00821                 BPF &f1 = in1.GetPhaseBPF();
00822                 Complex *c2 = in2.GetComplexArray().GetPtr();
00823                 Complex *co = out.GetComplexArray().GetPtr();
00824 /*****************************/
00825 //OPERATION: BPF AND COMPLEX
00826                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00827                 if(intFactor>1) intFactor=1;
00828                 if(intFactor<0) intFactor=0;
00829                 TData invIntFactor=1-intFactor;
00830 
00831                 for (int i=0;i<mSize;i++) {
00832                         TData BRe = fabs(m1.GetValue(pos)) * CLAM_cos(f1.GetValue(pos));
00833                         TData BIm = fabs(m1.GetValue(pos)) * CLAM_sin(f1.GetValue(pos));
00834                         co[i]= Complex(BRe,BIm)*invIntFactor + c2[i]*intFactor;
00835                         pos+=delta;
00836                 }
00837 
00838                 f.bMagPhase=f.bPolar=f.bMagPhaseBPF=false;
00839                 f.bComplex=true;
00840                 out.SynchronizeTo(f);
00841                 
00842                 if (remove2) {
00843                         in2.RemoveComplexArray();
00844                         in2.UpdateData();
00845                 }
00846                 if (remove3) {
00847                         out.RemoveComplexArray();
00848                         out.UpdateData();
00849                 }
00850         }
00851 
00852         // This is probably one of the most used methods, because it can be used
00853         // to apply a BPF filter in log scale to a linear complex spectrum, as the
00854         // one naturaly generated from a FFT
00855         void SpectrumInterpolator::InterpolateBPFComplexLogLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00856         {
00857                 bool remove2=false,remove3=false;
00858                 SpecTypeFlags f;
00859 
00860                 // This function was choosed because in1 is a BPF Spectrum,
00861                 // and some of the non-BPF data objects have their Complex
00862                 // attribute instantiated. We don't know which of them,
00863                 // though, out we must check and instantiate the attribute it
00864                 // it is missed. This could be optimised out by Interpolateing more
00865                 // States, see coments on this in the class declaration.
00866                 in2.GetType(f);
00867                 if (!f.bComplex) {
00868                         remove2=true;
00869                         f.bComplex=true;
00870                         in2.SetTypeSynchronize(f);
00871                 }
00872                 out.GetType(f);
00873                 if (!f.bComplex) {
00874                         remove3=true;
00875                         f.bComplex=true;
00876                         out.SetType(f);
00877                 }
00878 
00879                 TData pos = 0.0;
00880                 TData delta = out.GetSpectralRange() / 
00881                               ((TData)out.GetSize()-TData(1.0));
00882                 BPF &m1 = in1.GetMagBPF();
00883                 BPF &f1 = in1.GetPhaseBPF();
00884                 Complex *c2 = in2.GetComplexArray().GetPtr();
00885                 Complex *co = out.GetComplexArray().GetPtr();
00886 /*****************************/
00887 //OPERATION: BPF(LOG) AND COMPLEX
00888                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00889                 if(intFactor>1) intFactor=1;
00890                 if(intFactor<0) intFactor=0;
00891                 TData invIntFactor=1-intFactor;
00892 
00893                 for (int i=0;i<mSize;i++) {
00894                         TData BRe = CLAM_pow(TData(10),fabs(m1.GetValue(pos))/TData(10.0)) * CLAM_cos(f1.GetValue(pos));
00895                         TData BIm = CLAM_pow(TData(10),fabs(m1.GetValue(pos))/TData(10.0)) * CLAM_sin(f1.GetValue(pos));
00896                         co[i]= Complex(BRe,BIm)*invIntFactor + c2[i]*intFactor;
00897                         pos+=delta;
00898                 }
00899 
00900                 f.bMagPhase=f.bPolar=f.bMagPhaseBPF=false;
00901                 f.bComplex=true;
00902                 out.SynchronizeTo(f);
00903                 
00904                 
00905                 if (remove2) {
00906                         in2.RemoveComplexArray();
00907                         in2.UpdateData();
00908                 }
00909                 if (remove3) {
00910                         out.RemoveComplexArray();
00911                         out.UpdateData();
00912                 }
00913         }
00914 
00915 
00916         void SpectrumInterpolator::InterpolateBPFPolar(Spectrum& in1, Spectrum& in2, Spectrum& out)
00917         {
00918                 switch(mScaleState) {
00919                 case Slinlin:
00920                         InterpolateBPFPolarLin(in1,in2,out);
00921                         break;
00922                 case Sloglog:
00923                         InterpolateBPFPolarLog(in1,in2,out);
00924                         break;
00925                 case Slinlog:
00926                         CLAM_ASSERT(false,"InterpolateBPFPolarLinLog: Not implemented");
00927                         break;
00928                 case Sloglin:
00929                         InterpolateBPFPolarLogLin(in1,in2,out);
00930                         break;
00931                 }
00932         }
00933 
00934         void SpectrumInterpolator::InterpolatePolarBPF(Spectrum& in1, Spectrum& in2, Spectrum& out)
00935         {
00936                 switch(mScaleState) {
00937                 case Slinlin:
00938                         InterpolateBPFPolarLin(in2,in1,out);
00939                         break;
00940                 case Sloglog:
00941                         InterpolateBPFPolarLog(in2,in1,out);
00942                         break;
00943                 case Slinlog:
00944                         InterpolateBPFPolarLogLin(in2,in1,out);
00945                         break;
00946                 case Sloglin:
00947                         CLAM_ASSERT(false,"InterpolateBPFPolarLinLog: Not implemented");
00948                         break;
00949                 }
00950         }
00951 
00952         void SpectrumInterpolator::InterpolateBPFPolarLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
00953         {
00954                 bool remove2=false,remove3=false;
00955                 SpecTypeFlags f;
00956 
00957                 // This function was choosed because in1 is a BPF Spectrum,
00958                 // and some of the non-BPF data objects have their Polar
00959                 // attribute instantiated. We don't know which of them,
00960                 // though, out we must check and instantiate the attribute it
00961                 // it is missed. This could be optimised out by Interpolateing more
00962                 // States, see coments on this in the class declaration.
00963                 in2.GetType(f);
00964                 if (!f.bPolar) {
00965                         remove2=true;
00966                         f.bPolar=true;
00967                         in2.SetTypeSynchronize(f);
00968                 }
00969                 out.GetType(f);
00970                 if (!f.bPolar) {
00971                         remove3=true;
00972                         f.bPolar=true;
00973                         out.SetType(f);
00974                 }
00975 
00976                 TData pos = 0.0;
00977                 TData delta = out.GetSpectralRange() / 
00978                               ((TData)out.GetSize()-TData(1.0));
00979                 BPF &m1 = in1.GetMagBPF();
00980                 BPF &f1 = in1.GetPhaseBPF();
00981                 Polar *p2 = in2.GetPolarArray().GetPtr();
00982                 Polar *po = out.GetPolarArray().GetPtr();
00983 /*****************************/
00984 //OPERATION: BPF AND POLAR
00985                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
00986                 if(intFactor>1) intFactor=1;
00987                 if(intFactor<0) intFactor=0;
00988                 TData invIntFactor=1-intFactor;
00989                 Polar polInvIntFactor=Polar(invIntFactor);
00990                 Polar polIntFactor=Polar(intFactor);
00991                 
00992                 for (int i=0;i<mSize;i++) {
00993                         po[i]=polInvIntFactor*Polar(m1.GetValue(pos),f1.GetValue(pos))+polIntFactor*p2[i];
00994                         pos+=delta;
00995                 }
00996 
00997                 f.bMagPhase=f.bComplex=f.bMagPhaseBPF=false;
00998                 f.bPolar=true;
00999                 out.SynchronizeTo(f);
01000                 
01001                 if (remove2) {
01002                         in2.RemovePolarArray();
01003                         in2.UpdateData();
01004                 }
01005                 if (remove3) {
01006                         out.RemovePolarArray();
01007                         out.UpdateData();
01008                 }
01009         }
01010 
01011         void SpectrumInterpolator::InterpolateBPFPolarLogLin(Spectrum& in1, Spectrum& in2, Spectrum& out)
01012         {
01013                 bool remove2=false,remove3=false;
01014                 SpecTypeFlags f;
01015 
01016                 // This function was choosed because in1 is a BPF Spectrum,
01017                 // and some of the non-BPF data objects have their Polar
01018                 // attribute instantiated. We don't know which of them,
01019                 // though, out we must check and instantiate the attribute it
01020                 // it is missed. This could be optimised out by Interpolateing more
01021                 // States, see coments on this in the class declaration.
01022                 in2.GetType(f);
01023                 if (!f.bPolar) {
01024                         remove2=true;
01025                         f.bPolar=true;
01026                         in2.SetTypeSynchronize(f);
01027                 }
01028                 out.GetType(f);
01029                 if (!f.bPolar) {
01030                         remove3=true;
01031                         f.bPolar=true;
01032                         out.SetType(f);
01033                 }
01034 
01035                 TData pos = 0.0;
01036                 TData delta = out.GetSpectralRange() / 
01037                               ((TData)out.GetSize()-TData(1.0));
01038                 BPF &m1 = in1.GetMagBPF();
01039                 BPF &f1 = in1.GetPhaseBPF();
01040                 Polar *p2 = in2.GetPolarArray().GetPtr();
01041                 Polar *po = out.GetPolarArray().GetPtr();
01042 /*****************************/
01043 //OPERATION: BPF(LOG) AND POLAR
01044                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
01045                 if(intFactor>1) intFactor=1;
01046                 if(intFactor<0) intFactor=0;
01047                 TData invIntFactor=1-intFactor;
01048                 Polar polInvIntFactor=Polar(invIntFactor);
01049                 Polar polIntFactor=Polar(intFactor);
01050 
01051                 for (int i=0;i<mSize;i++) {
01052                         TData BMag = CLAM_pow(TData(10),m1.GetValue(pos)/TData(10.0));
01053                         TData BPha = f1.GetValue(pos);
01054                         po[i]=polInvIntFactor*Polar(BMag,BPha)+polIntFactor*p2[i];
01055                         pos+=delta;
01056                 }
01057 
01058                 f.bMagPhase=f.bComplex=f.bMagPhaseBPF=false;
01059                 f.bPolar=true;
01060                 out.SynchronizeTo(f);
01061                 
01062                 if (remove2) {
01063                         in2.RemovePolarArray();
01064                         in2.UpdateData();
01065                 }
01066                 if (remove3) {
01067                         out.RemovePolarArray();
01068                         out.UpdateData();
01069                 }
01070         }
01071 
01072         void SpectrumInterpolator::InterpolateBPF(Spectrum& in1, Spectrum& in2, Spectrum& out)
01073         {
01074                 
01075                 TData intFactor=mInterpolationFactorCtl.GetLastValue();
01076                 if(intFactor>1) intFactor=1;
01077                 if(intFactor<0) intFactor=0;
01078                 TData invIntFactor=1-intFactor;
01079 
01080                 // First we check if the abcisas agree
01081 
01082                 for (int i=0;i<mSize;i++) {
01083                         Point &pm1=in1.GetMagBPF().GetPointArray()[i];
01084                         Point &pm2=in2.GetMagBPF().GetPointArray()[i];
01085                         Point &pmo=out.GetMagBPF().GetPointArray()[i];
01086                         Point &pf1=in1.GetPhaseBPF().GetPointArray()[i];
01087                         Point &pf2=in2.GetPhaseBPF().GetPointArray()[i];
01088                         Point &pfo=out.GetPhaseBPF().GetPointArray()[i];
01089                         CLAM_ASSERT(pm1.GetX() == pm2.GetX(), "InterpolateBPF: input BPF abcisas do not match "
01090                                 "(and BPF merging not yet iplemented)");
01091                         CLAM_ASSERT(pm1.GetX() == pmo.GetX(), "InterpolateBPF: ouput BPF abcisas do not match with imput "
01092                                 "(and BPF merging not yet iplemented)");
01093 /*****************************/
01094 //OPERATION: BPF AND BPF
01095                         pmo.SetY(invIntFactor*pm1.GetY()+intFactor*pm2.GetY());
01096                         pfo.SetY(invIntFactor*pf1.GetY()+intFactor*pf2.GetY());
01097                 }
01098 
01099         }
01100 
01101         // UNINMPLEMENTED METHODS. some day...
01102         void SpectrumInterpolator::InterpolateMagPhaseLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01103         {
01104                 CLAM_ASSERT(false,"InterpolateMagPhaseLog: Not implemented");
01105         }
01106         void SpectrumInterpolator::InterpolateMagPhaseLinLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01107         {
01108                 CLAM_ASSERT(false,"InterpolateMagPhaseLinLog: Not implemented");
01109         }
01110         void SpectrumInterpolator::InterpolateComplexLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01111         {
01112                 CLAM_ASSERT(false,"InterpolateComplexLog: Not implemented");
01113         }
01114         void SpectrumInterpolator::InterpolateComplexLinLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01115         {
01116                 CLAM_ASSERT(false,"InterpolateComplexLinLog: Not implemented");
01117         }
01118         void SpectrumInterpolator::InterpolatePolarLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01119         {
01120                 CLAM_ASSERT(false,"InterpolatePolarLog: Not implemented");
01121         }
01122         void SpectrumInterpolator::InterpolatePolarLinLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01123         {
01124                 CLAM_ASSERT(false,"InterpolatePolarLinLog: Not implemented");
01125         }
01126         void SpectrumInterpolator::InterpolateBPFComplexLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01127         {
01128                 CLAM_ASSERT(false,"InterpolateBPFComplexLog: Not implemented");
01129         }
01130         void SpectrumInterpolator::InterpolateBPFComplexLinLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01131         {
01132                 CLAM_ASSERT(false,"InterpolateBPFComplexLinLog: Not implemented");
01133         }
01134         void SpectrumInterpolator::InterpolateBPFPolarLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01135         {
01136                 CLAM_ASSERT(false,"InterpolateBPFPolarLog: Not implemented");
01137         }
01138         void SpectrumInterpolator::InterpolateBPFPolarLinLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01139         {
01140                 CLAM_ASSERT(false,"InterpolateBPFPolarLinLog: Not implemented");
01141         }
01142         void SpectrumInterpolator::InterpolateBPFMagPhaseLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01143         {
01144                 CLAM_ASSERT(false,"InterpolateBPFMagPhaseLog: Not implemented");
01145         }
01146         void SpectrumInterpolator::InterpolateBPFMagPhaseLinLog(Spectrum& in1, Spectrum& in2, Spectrum& out)
01147         {
01148                 CLAM_ASSERT(false,"InterpolateBPFMagPhaseLinLog: Not implemented");
01149         }
01150 }
01151