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