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