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 "Spectrum.hxx" 00023 #include "SpectrumConfig.hxx" 00024 #include "SpecTypeFlags.hxx" 00025 #include "ArrayToBPFCnv.hxx" 00026 #include "ComplexToPolarCnv.hxx" 00027 #include "ProcessingDataPlugin.hxx" 00028 00029 using namespace CLAM; 00030 00031 namespace CLAM 00032 { 00033 namespace Hidden 00034 { 00035 static ProcessingDataPlugin::Registrator<Spectrum> dataRegistrator("yellowgreen"); 00036 } 00037 } 00038 Flags<4>::tFlagValue SpecTypeFlags::sFlagValues[] = { 00039 {SpecTypeFlags::eComplex, "Complex"}, 00040 {SpecTypeFlags::ePolar, "Polar"}, 00041 {SpecTypeFlags::eMagPhase, "MagPhase"}, 00042 {SpecTypeFlags::eMagPhaseBPF, "MagPhaseBPF"}, 00043 {0,NULL} 00044 }; 00045 00046 00048 // 00049 // SpectrumConfig 00050 // 00052 00056 void SpectrumConfig::DefaultInit() 00057 { 00058 AddScale(); 00059 AddSpectralRange(); 00060 AddType(); 00061 AddSize(); 00062 00063 SetPreAllocateAllAttributes(); 00064 UpdateData(); 00065 DefaultValues(); 00066 } 00067 00068 00069 void SpectrumConfig::DefaultValues() 00070 { 00071 SpecTypeFlags flags; // initilized with the default value 00072 SetType(flags); 00073 SetScale(EScale(EScale::eLinear)); 00074 SetSize(0); 00075 00076 SetSpectralRange(22050); 00077 } 00078 00079 00080 00082 // 00083 // Spectrum 00084 // 00086 00087 00088 Spectrum::Spectrum(const SpectrumConfig &newConfig) : ProcessingData(eNumAttr) 00089 { 00090 MandatoryInit(); // Macro-expanded function. Necessary for some dynamic type initialization. 00091 Configure(newConfig); 00092 } 00093 00094 void Spectrum::GetConfig(SpectrumConfig& c) const 00095 { 00096 SpecTypeFlags f; 00097 00098 f.bMagPhaseBPF = HasMagBPF() && HasPhaseBPF(); 00099 f.bMagPhase = HasMagBuffer() && HasPhaseBuffer(); 00100 f.bPolar = HasPolarArray(); 00101 f.bComplex = HasComplexArray(); 00102 00103 c.SetType(f); 00104 c.SetSize( GetSize() ); 00105 c.SetSpectralRange(GetSpectralRange()); 00106 c.SetScale(GetScale()); 00107 00108 if (GetBPFSize()<0 || GetBPFSize()==GetSize()) { 00109 c.RemoveBPFSize(); 00110 c.UpdateData(); 00111 } 00112 else 00113 { 00114 c.AddBPFSize(); 00115 c.UpdateData(); 00116 c.SetBPFSize( GetBPFSize() ); 00117 } 00118 } 00119 00120 00121 00122 void Spectrum::DefaultInit() 00123 { 00124 Configure(SpectrumConfig()); 00125 } 00126 00127 void Spectrum::Configure(const SpectrumConfig &newConfig) 00128 { 00129 AddScale(); 00130 AddSpectralRange(); 00131 AddprSize(); 00132 00133 SetPreAllocateAllAttributes(); 00134 UpdateData(); 00135 00136 SetScale(newConfig.GetScale()); 00137 SetSpectralRange(newConfig.GetSpectralRange()); 00138 int bpfsize= newConfig.HasBPFSize() ? newConfig.GetBPFSize() : newConfig.GetSize(); 00139 PRSetType(newConfig.GetType(),newConfig.GetSize(),bpfsize); 00140 } 00141 00142 void Spectrum::PRSetType(const SpecTypeFlags& tmpFlags,int size, int bpfsize) 00143 { 00144 if(tmpFlags.bMagPhase) 00145 { 00146 AddMagBuffer(); 00147 AddPhaseBuffer(); 00148 } 00149 else 00150 { 00151 RemoveMagBuffer(); 00152 RemovePhaseBuffer(); 00153 } 00154 if(tmpFlags.bComplex) 00155 { 00156 AddComplexArray(); 00157 } 00158 else 00159 { 00160 RemoveComplexArray(); 00161 } 00162 if(tmpFlags.bPolar) 00163 { 00164 AddPolarArray(); 00165 } 00166 else 00167 { 00168 RemovePolarArray(); 00169 } 00170 if(tmpFlags.bMagPhaseBPF) 00171 { 00172 AddMagBPF(); 00173 AddPhaseBPF(); 00174 } 00175 else 00176 { 00177 RemoveMagBPF(); 00178 RemovePhaseBPF(); 00179 } 00180 UpdateData(); 00181 SetSize(size); 00182 SetBPFSize(bpfsize); 00183 00184 } 00185 00186 void Spectrum::SetType(const SpecTypeFlags& tmpFlags) 00187 { 00188 int size = GetSize(); 00189 int bpfsize= HasprBPFSize() ? GetprBPFSize() : size; 00190 PRSetType(tmpFlags,size,bpfsize); 00191 } 00192 00193 00194 /* @TODO: These methods use a limit for -INFINITY dB and 0 linear, these limits should be 00195 set as constants elsewhere */ 00196 void Spectrum::ToDB() 00197 { 00198 if(GetScale()!=EScale::eLinear) 00199 return; 00200 00201 int i; 00202 SpecTypeFlags flags; 00203 TSize specSize = GetSize(); 00204 if (HasMagBuffer()) 00205 { 00206 DataArray &mag = GetMagBuffer(); 00207 for (i=0; i<specSize; i++) 00208 { 00209 #ifdef CLAM_OPTIMIZE 00210 //we discard magnitudes lower than 100 dB 00211 //todo: this optimization should also be applied to other places 00212 if(mag[i]<0.00001f) mag[i]=-200; 00213 #else 00214 if(mag[i]==0) mag[i]=-200; 00215 #endif 00216 else mag[i]= CLAM_20log10(mag[i]); 00217 } 00218 } 00219 if (HasPolarArray()) // WARNING: computational expensive operation 00220 { 00221 Array<Polar> &polar = GetPolarArray(); 00222 for (i=0; i<specSize; i++) 00223 { 00224 TData magLin = polar[i].Mag(); 00225 TData magLog; 00226 #ifdef CLAM_OPTIMIZE 00227 //we discard magnitudes lower than 100 dB 00228 //todo: this optimization should also be applied to the reverse conversion 00229 if(magLin<0.00001f) magLog=-200; 00230 #else 00231 if(magLin==0) magLog=-200; 00232 #endif 00233 else magLog = CLAM_20log10(magLin); 00234 polar[i].SetMag(magLog); 00235 } 00236 flags.bPolar = true; 00237 flags.bMagPhase = false; 00238 } 00239 if (HasComplexArray()) // WARNING: computational expensive operation 00240 { 00241 Array<Complex> &complex = GetComplexArray(); 00242 for (i=0; i<specSize; i++) 00243 { 00244 TData re = complex[i].Real(); 00245 TData im = complex[i].Imag(); 00246 TData magLin = CLAM_sqrt(re*re + im*im); 00247 TData magLog; 00248 #ifdef CLAM_OPTIMIZE 00249 if(magLin<0.00001f) magLog=-200; 00250 #else 00251 if(magLin==0) magLog=-200; 00252 #endif 00253 else magLog = CLAM_20log10(magLin); 00254 complex[i].SetReal(magLog * re / magLin); 00255 complex[i].SetImag(magLog * im / magLin); 00256 } 00257 flags.bComplex = true; 00258 flags.bMagPhase = false; 00259 } 00260 if (HasMagBPF()) // WARNING: computational expensive operation 00261 { 00262 BPF &magBPF= GetMagBPF(); 00263 const int bpfSize=GetBPFSize(); 00264 for (i=0; i<bpfSize; i++) 00265 { 00266 TData magLin=magBPF.GetValueFromIndex(i); 00267 TData magLog; 00268 #ifdef CLAM_OPTIMIZE 00269 if(magLin<0.00001f) magLog=-200; 00270 #else 00271 if(magLin==0) magLog=-200; 00272 #endif 00273 else magLog = CLAM_20log10(magLin); 00274 magBPF.SetValue(i,magLog); 00275 } 00276 flags.bMagPhaseBPF = true; 00277 flags.bMagPhase = false; 00278 } 00279 SetScale(EScale(EScale::eLog)); 00280 } 00281 00282 00283 void Spectrum::ToLinear() 00284 { 00285 if(GetScale()==EScale::eLog) 00286 { 00287 int i; 00288 SpecTypeFlags flags; 00289 TSize specSize = GetSize(); 00290 if (HasMagBuffer()) 00291 { 00292 DataArray &mag = GetMagBuffer(); 00293 for (i=0; i<specSize; i++) 00294 { 00295 if(mag[i]<=-200) mag[i]=0; 00296 else mag[i]= log2lin(mag[i]); 00297 } 00298 } 00299 if (HasPolarArray()) // WARNING: computational expensive operation 00300 { 00301 Array<Polar> &polar = GetPolarArray(); 00302 for (i=0; i<specSize; i++) 00303 { 00304 TData magLog = polar[i].Mag(); 00305 TData magLin; 00306 if(magLog<=-200) magLin=0; 00307 else magLin = log2lin(magLog); 00308 polar[i].SetMag(magLin); 00309 } 00310 flags.bPolar = true; 00311 flags.bMagPhase = false; 00312 } 00313 if (HasComplexArray()) // WARNING: computational expensive operation 00314 { 00315 Array<Complex> &complex = GetComplexArray(); 00316 for (i=0; i<specSize; i++) 00317 { 00318 TData re = complex[i].Real(); 00319 TData im = complex[i].Imag(); 00320 TData magLog = CLAM_sqrt(re*re + im*im); 00321 TData magLin; 00322 if(magLog<=-200) magLin=0; 00323 else magLin = log2lin(magLog); 00324 complex[i].SetReal(magLin * re / magLin); 00325 complex[i].SetImag(magLin * im / magLin); 00326 } 00327 flags.bComplex = true; 00328 flags.bMagPhase = false; 00329 } 00330 if (HasMagBPF()) // WARNING: computational expensive operation 00331 { 00332 BPF &magBPF = GetMagBPF(); 00333 int bpfSize=GetBPFSize(); 00334 for (i=0; i<bpfSize; i++) 00335 { 00336 TData magLog = magBPF.GetValueFromIndex(i); 00337 TData magLin; 00338 if(magLog<=-200) magLin=0; 00339 else magLin = log2lin(magLog); 00340 magBPF.SetValue(i,magLin); 00341 } 00342 flags.bMagPhaseBPF = true; 00343 flags.bMagPhase = false; 00344 } 00345 SetScale(EScale(EScale::eLinear)); 00346 00347 } 00348 } 00349 00350 TData Spectrum::GetMag(TIndex pos) const 00351 { 00352 SpecTypeFlags tmpFlags; 00353 GetType(tmpFlags); 00354 if(tmpFlags.bMagPhase) 00355 return GetMagBuffer()[pos]; 00356 if (tmpFlags.bMagPhaseBPF) 00357 return GetMagBPF().GetValueFromIndex(pos); 00358 if (tmpFlags.bPolar) 00359 return GetPolarArray()[pos].Mag(); 00360 if (tmpFlags.bComplex) 00361 return GetComplexArray()[pos].Mag(); 00362 CLAM_ASSERT(false, "Spectrum::GetMag: Spectrum no initialized"); 00363 return 0; 00364 } 00365 00366 TData Spectrum::GetMag(TData freq) const 00367 { 00368 SpecTypeFlags tmpFlags; 00369 GetType(tmpFlags); 00370 TIndex pos = IndexFromFreq(freq); 00371 if (tmpFlags.bMagPhaseBPF) 00372 return GetMagBPF().GetValue(freq); 00373 if(tmpFlags.bMagPhase) 00374 return GetMagBuffer()[pos]; 00375 if (tmpFlags.bPolar) 00376 return GetPolarArray()[pos].Mag(); 00377 if (tmpFlags.bComplex) 00378 return GetComplexArray()[pos].Mag(); 00379 CLAM_ASSERT(false, "Spectrum::GetMag: Spectrum no initialized"); 00380 return 0; 00381 } 00382 00383 TData Spectrum::GetPhase(TIndex pos) const 00384 { 00385 SpecTypeFlags tmpFlags; 00386 GetType(tmpFlags); 00387 if(tmpFlags.bMagPhase) 00388 return GetPhaseBuffer()[pos]; 00389 if (tmpFlags.bMagPhaseBPF) 00390 return GetPhaseBPF().GetValueFromIndex(pos); 00391 if (tmpFlags.bPolar) 00392 return GetPolarArray()[pos].Ang(); 00393 if (tmpFlags.bComplex) 00394 return GetComplexArray()[pos].Ang(); 00395 CLAM_ASSERT(false, "Spectrum::GetPhase: Spectrum no initialized"); 00396 return 0; 00397 } 00398 00399 TData Spectrum::GetPhase(TData freq) const 00400 { 00401 SpecTypeFlags tmpFlags; 00402 GetType(tmpFlags); 00403 TIndex pos = IndexFromFreq(freq); 00404 if (tmpFlags.bMagPhaseBPF) 00405 return GetPhaseBPF().GetValue(freq); 00406 if(tmpFlags.bMagPhase) 00407 return GetPhaseBuffer()[pos]; 00408 if (tmpFlags.bPolar) 00409 return GetPolarArray()[pos].Ang(); 00410 if (tmpFlags.bComplex) 00411 return GetComplexArray()[pos].Ang(); 00412 CLAM_ASSERT(false, "Spectrum::GetPhase: Spectrum no initialized"); 00413 return 0; 00414 } 00415 00416 void Spectrum::SetMag(TIndex pos, TData newMag) 00417 { 00418 SpecTypeFlags tmpFlags; 00419 GetType(tmpFlags); 00420 if(tmpFlags.bMagPhase) 00421 GetMagBuffer()[pos]=newMag; 00422 if (tmpFlags.bMagPhaseBPF) 00423 GetMagBPF().SetValue(pos,newMag); 00424 if (tmpFlags.bPolar) 00425 GetPolarArray()[pos].SetMag(newMag); 00426 if (tmpFlags.bComplex){ 00427 TData tmpAng=GetComplexArray()[pos].Ang(); 00428 GetComplexArray()[pos].SetReal(newMag*CLAM_cos(tmpAng)); 00429 GetComplexArray()[pos].SetImag(newMag*CLAM_sin(tmpAng));} 00430 } 00431 00432 void Spectrum::SetMag(TData freq, TData newMag) 00433 { 00434 SetMag(IndexFromFreq(freq),newMag); 00435 } 00436 00437 void Spectrum::SetPhase(TIndex pos,TData newPhase)//inefficient Set, for efficiency work directly on the buffer 00438 { 00439 SpecTypeFlags tmpFlags; 00440 GetType(tmpFlags); 00441 if(tmpFlags.bMagPhase) 00442 GetPhaseBuffer()[pos]=newPhase; 00443 else if (tmpFlags.bMagPhaseBPF) 00444 GetPhaseBPF().SetValue(pos,newPhase); 00445 else if (tmpFlags.bPolar) 00446 GetPolarArray()[pos].SetAng(newPhase); 00447 else if (tmpFlags.bComplex){ 00448 TData tmpMag=GetComplexArray()[pos].Mag(); 00449 GetComplexArray()[pos].SetReal(tmpMag*CLAM_cos(newPhase)); 00450 GetComplexArray()[pos].SetImag(tmpMag*CLAM_sin(newPhase)); 00451 } 00452 } 00453 00454 void Spectrum::SetPhase(TData freq, TData newPhase) 00455 { 00456 SetPhase(IndexFromFreq(freq),newPhase); 00457 } 00458 00459 void Spectrum::SynchronizeTo(const SpecTypeFlags& tmpFlags) 00460 { 00461 SynchronizeTo(tmpFlags,(*this)); 00462 } 00463 00464 void Spectrum::SynchronizeTo(const SpecTypeFlags& tmpFlags,const Spectrum& in) 00465 { 00466 //if tmpFlags are set so different synchronizations are possible, the easiest one is chosen 00467 00468 SpecTypeFlags currentFlags; 00469 GetType(currentFlags); 00470 int size = GetSize(); 00471 00472 if(tmpFlags.bMagPhase) 00473 { 00474 if(currentFlags.bPolar) MagPhase2Polar(in); 00475 if(currentFlags.bComplex) MagPhase2Complex(in); 00476 if(currentFlags.bMagPhaseBPF) MagPhase2BPF(in); 00477 } 00478 else if(tmpFlags.bComplex) 00479 { 00480 if(currentFlags.bPolar) Complex2Polar(in); 00481 if(currentFlags.bMagPhase) Complex2MagPhase(in); 00482 if(currentFlags.bMagPhaseBPF) 00483 { 00484 if(currentFlags.bMagPhase) MagPhase2BPF(); 00485 else 00486 { 00487 AddMagBuffer(); 00488 AddPhaseBuffer(); 00489 UpdateData(); 00490 GetMagBuffer().Resize(size); 00491 GetPhaseBuffer().Resize(size); 00492 GetMagBuffer().SetSize(size); 00493 GetPhaseBuffer().SetSize(size); 00494 Complex2MagPhase(in); 00495 MagPhase2BPF(); 00496 00497 RemoveMagBuffer(); 00498 RemovePhaseBuffer(); 00499 UpdateData(); 00500 } 00501 } 00502 } 00503 else if(tmpFlags.bPolar) 00504 { 00505 if(currentFlags.bComplex) Polar2Complex(in); 00506 if(currentFlags.bMagPhase) Polar2MagPhase(in); 00507 if(currentFlags.bMagPhaseBPF) 00508 { 00509 if(currentFlags.bMagPhase) MagPhase2BPF(); 00510 else 00511 { 00512 AddMagBuffer(); 00513 AddPhaseBuffer(); 00514 UpdateData(); 00515 GetMagBuffer().Resize(size); 00516 GetPhaseBuffer().Resize(size); 00517 GetMagBuffer().SetSize(size); 00518 GetPhaseBuffer().SetSize(size); 00519 Polar2MagPhase(in); 00520 MagPhase2BPF(); 00521 00522 RemoveMagBuffer(); 00523 RemovePhaseBuffer(); 00524 UpdateData(); 00525 } 00526 } 00527 } 00528 else if(tmpFlags.bMagPhaseBPF) 00529 { 00530 bool deleteMagPhase=false; 00531 if(!currentFlags.bMagPhase) 00532 { 00533 deleteMagPhase=true; 00534 AddMagBuffer(); 00535 AddPhaseBuffer(); 00536 UpdateData(); 00537 GetMagBuffer().Resize(size); 00538 GetPhaseBuffer().Resize(size); 00539 GetMagBuffer().SetSize(size); 00540 GetPhaseBuffer().SetSize(size); 00541 } 00542 BPF2MagPhase(in); 00543 00544 if(currentFlags.bPolar) MagPhase2Polar(); 00545 if(currentFlags.bComplex) MagPhase2Complex(); 00546 if(deleteMagPhase) 00547 { 00548 RemoveMagBuffer(); 00549 RemovePhaseBuffer(); 00550 UpdateData(); 00551 } 00552 } 00553 00554 00555 } 00556 00557 00558 void Spectrum::SynchronizeTo(const Spectrum& in) 00559 { 00560 //if tmpFlags are set so different synchronizations are possible, the easiest one is chosen 00561 00562 SpecTypeFlags tmpFlags; 00563 in.GetType(tmpFlags); 00564 00565 SynchronizeTo(tmpFlags,in); 00566 00567 00568 00569 } 00570 00572 00573 00574 void Spectrum::Complex2Polar(const Spectrum& in) 00575 { 00576 ComplexToPolarCnv_ convert; 00577 convert.ToPolar(in.GetComplexArray(), GetPolarArray()); 00578 } 00579 00580 void Spectrum::Complex2Polar() 00581 { 00582 ComplexToPolarCnv_ convert; 00583 convert.ToPolar(GetComplexArray(), GetPolarArray()); 00584 } 00585 00586 void Spectrum::Polar2Complex(const Spectrum& in) 00587 { 00588 ComplexToPolarCnv_ convert; 00589 convert.ToComplex(in.GetPolarArray(),GetComplexArray()); 00590 } 00591 00592 void Spectrum::Polar2Complex() 00593 { 00594 ComplexToPolarCnv_ convert; 00595 convert.ToComplex(GetPolarArray(),GetComplexArray()); 00596 } 00597 00598 void Spectrum::Polar2MagPhase(const Array<Polar>& polarArray,DataArray& magBuffer, DataArray& phaseBuffer) 00599 { 00600 int size = GetSize(); 00601 for (int i=0; i<size; i++) 00602 { 00603 magBuffer[i] = polarArray[i].Mag(); 00604 phaseBuffer[i] = polarArray[i].Ang(); 00605 } 00606 } 00607 00608 void Spectrum::Polar2MagPhase(const Spectrum& in) 00609 { 00610 Polar2MagPhase(in.GetPolarArray(),GetMagBuffer(),GetPhaseBuffer()); 00611 } 00612 00613 void Spectrum::Polar2MagPhase() 00614 { 00615 Polar2MagPhase(GetPolarArray(),GetMagBuffer(),GetPhaseBuffer()); 00616 } 00617 00618 void Spectrum::Complex2MagPhase(const Array<Complex>& complexArray, DataArray& magBuffer, DataArray& phaseBuffer) 00619 { 00620 int size = GetSize(); 00621 for (int i=0; i<size; i++) 00622 { 00623 magBuffer[i] = complexArray[i].Mag(); 00624 phaseBuffer[i] = complexArray[i].Ang(); 00625 } 00626 } 00627 00628 void Spectrum::Complex2MagPhase(const Spectrum& in) 00629 { 00630 Complex2MagPhase(in.GetComplexArray(),GetMagBuffer(),GetPhaseBuffer()); 00631 } 00632 00633 void Spectrum::Complex2MagPhase() 00634 { 00635 Complex2MagPhase(GetComplexArray(),GetMagBuffer(),GetPhaseBuffer()); 00636 } 00637 00638 void Spectrum::MagPhase2Polar(const DataArray& magBuffer,const DataArray& phaseBuffer,Array<Polar>& polarArray) 00639 { 00640 int size = GetSize(); 00641 for (int i=0; i<size; i++) 00642 { 00643 polarArray[i].SetMag(magBuffer[i]); 00644 polarArray[i].SetAng(phaseBuffer[i]); 00645 } 00646 } 00647 00648 void Spectrum::MagPhase2Polar(const Spectrum& in) 00649 { 00650 MagPhase2Polar(in.GetMagBuffer(),in.GetPhaseBuffer(),GetPolarArray()); 00651 00652 } 00653 00654 void Spectrum::MagPhase2Polar() 00655 { 00656 MagPhase2Polar(GetMagBuffer(),GetPhaseBuffer(),GetPolarArray()); 00657 00658 } 00659 00660 void Spectrum::MagPhase2Complex(const DataArray& magBuffer,const DataArray& phaseBuffer,Array<Complex>& complexArray) 00661 { 00662 int size = GetSize(); 00663 /* Xamat: I think this is not necessary, check in tests 00664 complexArray.Resize(size); 00665 complexArray.SetSize(size);*/ 00666 for (int i=0; i<size; i++) 00667 { 00668 complexArray[i].SetReal(magBuffer[i]*CLAM_cos(phaseBuffer[i])); 00669 complexArray[i].SetImag(magBuffer[i]*CLAM_sin(phaseBuffer[i])); 00670 } 00671 } 00672 00673 void Spectrum::MagPhase2Complex(const Spectrum& in) 00674 { 00675 MagPhase2Complex(in.GetMagBuffer(), in.GetPhaseBuffer(),GetComplexArray()); 00676 } 00677 00678 void Spectrum::MagPhase2Complex() 00679 { 00680 MagPhase2Complex(GetMagBuffer(), GetPhaseBuffer(),GetComplexArray()); 00681 } 00682 00683 void Spectrum::MagPhase2BPF(const DataArray& magBuffer, const DataArray& phaseBuffer, BPF& magBPF, BPF& phaseBPF) 00684 { 00685 int size = GetSize(); 00686 CLAM_ASSERT(size == GetBPFSize(), 00687 "Spectrum::MagPhase2BPF(): BPFSize and MagPhase size differ."); 00688 00689 DataArray freqBuffer(size); 00690 TData delta = GetSpectralRange()/(size-1); 00691 00692 ConvertToBPF( magBPF, TData(0), delta, magBuffer ); 00693 ConvertToBPF( phaseBPF, TData(0), delta, phaseBuffer ); 00694 } 00695 00696 00697 void Spectrum::MagPhase2BPF(const Spectrum& in) 00698 { 00699 MagPhase2BPF(in.GetMagBuffer(),in.GetPhaseBuffer(),GetMagBPF(),GetPhaseBPF()); 00700 } 00701 00702 void Spectrum::MagPhase2BPF() 00703 { 00704 MagPhase2BPF(GetMagBuffer(),GetPhaseBuffer(),GetMagBPF(),GetPhaseBPF()); 00705 } 00706 00707 void Spectrum::BPF2MagPhase( const BPF& magBPF, const BPF& phaseBPF, DataArray& magBuffer, DataArray& phaseBuffer) 00708 { 00709 int i; 00710 TData freq; 00711 int size = GetSize(); 00712 TData delta = GetSpectralRange()/(size-1); 00713 for(i=0; i<size; i++){ 00714 freq = i*delta; 00715 magBuffer[i] = magBPF.GetValue(freq); // interpolation 00716 phaseBuffer[i]= phaseBPF.GetValue(freq); 00717 } 00718 } 00719 00720 void Spectrum::BPF2MagPhase(const Spectrum& in) 00721 { 00722 BPF2MagPhase(in.GetMagBPF(),in.GetPhaseBPF(),GetMagBuffer(),GetPhaseBuffer()); 00723 } 00724 00725 void Spectrum::BPF2MagPhase() 00726 { 00727 BPF2MagPhase(GetMagBPF(),GetPhaseBPF(),GetMagBuffer(),GetPhaseBuffer()); 00728 } 00729 00730 00731 00732 int Spectrum::GetSize() const 00733 { 00734 const int size= GetprSize(); 00735 00736 CLAM_BEGIN_CHECK 00737 if(HasMagBuffer() && GetMagBuffer().Size()) 00738 CLAM_ASSERT(GetMagBuffer().Size() == size, 00739 "Spectrum::GetSize(): Mag size and Size mismatch."); 00740 if(HasPhaseBuffer() && GetPhaseBuffer().Size()) 00741 CLAM_ASSERT(GetPhaseBuffer().Size() == size, 00742 "Spectrum::GetSize(): Phase size and Size mismatch."); 00743 if(HasComplexArray() && GetComplexArray().Size()) 00744 CLAM_ASSERT(GetComplexArray().Size() == size, 00745 "Spectrum::GetSize(): Complex size and Size mismatch."); 00746 if(HasPolarArray() && GetPolarArray().Size()) 00747 CLAM_ASSERT(GetPolarArray().Size() == size, 00748 "Spectrum::GetSize(): Polar size and Size mismatch."); 00749 if (!HasprBPFSize()) { 00750 if(HasMagBPF() && GetMagBPF().Size()) 00751 CLAM_ASSERT(GetMagBPF().Size() == size, 00752 "Spectrum::GetSize(): MagBPF size and Size mismatch."); 00753 if(HasPhaseBPF() && GetPhaseBPF().Size()) 00754 CLAM_ASSERT(GetPhaseBPF().Size() == size, 00755 "Spectrum::GetSize(): PhaseBPF size and Size mismatch."); 00756 } 00757 CLAM_END_CHECK 00758 00759 return size; 00760 } 00761 00762 00763 void Spectrum::SetSize(int newSize) 00764 { 00765 SetprSize(newSize); 00766 00767 if(HasMagBuffer()){ 00768 GetMagBuffer().Resize(newSize); 00769 GetMagBuffer().SetSize(newSize);} 00770 if(HasPhaseBuffer()){ 00771 GetPhaseBuffer().Resize(newSize); 00772 GetPhaseBuffer().SetSize(newSize);} 00773 if (HasPolarArray()){ 00774 GetPolarArray().Resize(newSize); 00775 GetPolarArray().SetSize(newSize);} 00776 if (HasComplexArray()){ 00777 GetComplexArray().Resize(newSize); 00778 GetComplexArray().SetSize(newSize);} 00779 if (!HasprBPFSize()) { 00780 if (HasMagBPF()){ 00781 GetMagBPF().Resize(newSize); 00782 GetMagBPF().SetSize(newSize);} 00783 if (HasPhaseBPF()) { 00784 GetPhaseBPF().Resize(newSize); 00785 GetPhaseBPF().SetSize(newSize);} 00786 } 00787 } 00788 00789 int Spectrum::GetBPFSize() const 00790 { 00791 const int bpfsize= HasprBPFSize() ? GetprBPFSize() : GetSize(); 00792 00793 CLAM_BEGIN_CHECK 00794 CLAM_ASSERT(! (HasMagBPF() && GetMagBPF().Size() && GetMagBPF().Size() != bpfsize) , 00795 "Spectrum::GetBPFSize(): MagBPF size and BPFSize mismatch."); 00796 CLAM_ASSERT(!(HasPhaseBPF() && GetPhaseBPF().Size() && GetPhaseBPF().Size() != bpfsize), 00797 "Spectrum::GetBPFSize(): PhaseBPF size and BPFSize mismatch."); 00798 CLAM_END_CHECK 00799 00800 return bpfsize; 00801 } 00802 00803 void Spectrum::SetBPFSize(int s) 00804 { 00805 if (s != GetprSize()) { 00806 AddprBPFSize(); 00807 UpdateData(); 00808 SetprBPFSize(s); 00809 } 00810 else { 00811 RemoveprBPFSize(); 00812 UpdateData(); 00813 } 00814 00815 if (HasMagBPF() && HasPhaseBPF()) 00816 { 00817 GetMagBPF().Resize(s); 00818 GetMagBPF().SetSize(s); 00819 GetPhaseBPF().Resize(s); 00820 GetPhaseBPF().SetSize(s); 00821 } 00822 } 00823 00824 void Spectrum::SetTypeSynchronize(const SpecTypeFlags& newFlags) 00825 { 00826 SpecTypeFlags previousFlags; 00827 GetType(previousFlags ); 00828 SpecTypeFlags tmpFlags; 00829 00830 tmpFlags.bComplex = previousFlags.bComplex | newFlags.bComplex; 00831 tmpFlags.bPolar = previousFlags.bPolar | newFlags.bPolar; 00832 tmpFlags.bMagPhase = previousFlags.bMagPhase | newFlags.bMagPhase; 00833 tmpFlags.bMagPhaseBPF = previousFlags.bMagPhaseBPF | newFlags.bMagPhaseBPF; 00834 00835 SetType(tmpFlags); 00836 SynchronizeTo(previousFlags); 00837 SetType(newFlags); 00838 } 00839 00840 00841 void Spectrum::GetType(SpecTypeFlags& f) const 00842 { 00843 f.bMagPhaseBPF = HasMagBPF() && HasPhaseBPF(); 00844 f.bMagPhase = HasMagBuffer() && HasPhaseBuffer(); 00845 f.bPolar = HasPolarArray(); 00846 f.bComplex = HasComplexArray(); 00847 } 00848 00849 TIndex Spectrum::IndexFromFreq(TData freq) const 00850 { 00851 return Round(freq*((GetSize()-1)/GetSpectralRange())); 00852 } 00853