CLAM-Development  1.4.0
Spectrum.cxx
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2001-2004 MUSIC TECHNOLOGY GROUP (MTG)
3  * UNIVERSITAT POMPEU FABRA
4  *
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19  *
20  */
21 
22 #include "Spectrum.hxx"
23 #include "SpectrumConfig.hxx"
24 #include "SpecTypeFlags.hxx"
25 #include "ArrayToBPFCnv.hxx"
26 #include "ComplexToPolarCnv.hxx"
27 #include "ProcessingDataPlugin.hxx"
28 
29 using namespace CLAM;
30 
31 namespace CLAM
32 {
33  namespace Hidden
34  {
36  }
37 }
39  {SpecTypeFlags::eComplex, "Complex"},
40  {SpecTypeFlags::ePolar, "Polar"},
41  {SpecTypeFlags::eMagPhase, "MagPhase"},
42  {SpecTypeFlags::eMagPhaseBPF, "MagPhaseBPF"},
43  {0,NULL}
44 };
45 
46 
48 //
49 // SpectrumConfig
50 //
52 
57 {
58  AddScale();
59  AddSpectralRange();
60  AddType();
61  AddSize();
62 
64  UpdateData();
65  DefaultValues();
66 }
67 
68 
70 {
71  SpecTypeFlags flags; // initilized with the default value
72  SetType(flags);
73  SetScale(EScale(EScale::eLinear));
74  SetSize(0);
75 
76  SetSpectralRange(22050);
77 }
78 
79 
80 
82 //
83 // Spectrum
84 //
86 
87 
88 Spectrum::Spectrum(const SpectrumConfig &newConfig) : ProcessingData(eNumAttr)
89 {
90  MandatoryInit(); // Macro-expanded function. Necessary for some dynamic type initialization.
91  Configure(newConfig);
92 }
93 
95 {
96  SpecTypeFlags f;
97 
98  f.bMagPhaseBPF = HasMagBPF() && HasPhaseBPF();
99  f.bMagPhase = HasMagBuffer() && HasPhaseBuffer();
100  f.bPolar = HasPolarArray();
101  f.bComplex = HasComplexArray();
102 
103  c.SetType(f);
104  c.SetSize( GetSize() );
105  c.SetSpectralRange(GetSpectralRange());
106  c.SetScale(GetScale());
107 
108  if (GetBPFSize()<0 || GetBPFSize()==GetSize()) {
109  c.RemoveBPFSize();
110  c.UpdateData();
111  }
112  else
113  {
114  c.AddBPFSize();
115  c.UpdateData();
116  c.SetBPFSize( GetBPFSize() );
117  }
118 }
119 
120 
121 
123 {
125 }
126 
127 void Spectrum::Configure(const SpectrumConfig &newConfig)
128 {
129  AddScale();
130  AddSpectralRange();
131  AddprSize();
132 
134  UpdateData();
135 
136  SetScale(newConfig.GetScale());
137  SetSpectralRange(newConfig.GetSpectralRange());
138  int bpfsize= newConfig.HasBPFSize() ? newConfig.GetBPFSize() : newConfig.GetSize();
139  PRSetType(newConfig.GetType(),newConfig.GetSize(),bpfsize);
140 }
141 
142 void Spectrum::PRSetType(const SpecTypeFlags& tmpFlags,int size, int bpfsize)
143 {
144  if(tmpFlags.bMagPhase)
145  {
146  AddMagBuffer();
147  AddPhaseBuffer();
148  }
149  else
150  {
151  RemoveMagBuffer();
152  RemovePhaseBuffer();
153  }
154  if(tmpFlags.bComplex)
155  {
156  AddComplexArray();
157  }
158  else
159  {
160  RemoveComplexArray();
161  }
162  if(tmpFlags.bPolar)
163  {
164  AddPolarArray();
165  }
166  else
167  {
168  RemovePolarArray();
169  }
170  if(tmpFlags.bMagPhaseBPF)
171  {
172  AddMagBPF();
173  AddPhaseBPF();
174  }
175  else
176  {
177  RemoveMagBPF();
178  RemovePhaseBPF();
179  }
180  UpdateData();
181  SetSize(size);
182  SetBPFSize(bpfsize);
183 
184 }
185 
186 void Spectrum::SetType(const SpecTypeFlags& tmpFlags)
187 {
188  int size = GetSize();
189  int bpfsize= HasprBPFSize() ? GetprBPFSize() : size;
190  PRSetType(tmpFlags,size,bpfsize);
191 }
192 
193 
194 /* @TODO: These methods use a limit for -INFINITY dB and 0 linear, these limits should be
195 set as constants elsewhere */
197 {
198  if(GetScale()!=EScale::eLinear)
199  return;
200 
201  int i;
202  SpecTypeFlags flags;
203  TSize specSize = GetSize();
204  if (HasMagBuffer())
205  {
206  DataArray &mag = GetMagBuffer();
207  for (i=0; i<specSize; i++)
208  {
209 #ifdef CLAM_OPTIMIZE
210  //we discard magnitudes lower than 100 dB
211  //todo: this optimization should also be applied to other places
212  if(mag[i]<0.00001f) mag[i]=-200;
213 #else
214  if(mag[i]==0) mag[i]=-200;
215 #endif
216  else mag[i]= CLAM_20log10(mag[i]);
217  }
218  }
219  if (HasPolarArray()) // WARNING: computational expensive operation
220  {
221  Array<Polar> &polar = GetPolarArray();
222  for (i=0; i<specSize; i++)
223  {
224  TData magLin = polar[i].Mag();
225  TData magLog;
226 #ifdef CLAM_OPTIMIZE
227  //we discard magnitudes lower than 100 dB
228  //todo: this optimization should also be applied to the reverse conversion
229  if(magLin<0.00001f) magLog=-200;
230 #else
231  if(magLin==0) magLog=-200;
232 #endif
233  else magLog = CLAM_20log10(magLin);
234  polar[i].SetMag(magLog);
235  }
236  flags.bPolar = true;
237  flags.bMagPhase = false;
238  }
239  if (HasComplexArray()) // WARNING: computational expensive operation
240  {
241  Array<Complex> &complex = GetComplexArray();
242  for (i=0; i<specSize; i++)
243  {
244  TData re = complex[i].Real();
245  TData im = complex[i].Imag();
246  TData magLin = CLAM_sqrt(re*re + im*im);
247  TData magLog;
248 #ifdef CLAM_OPTIMIZE
249  if(magLin<0.00001f) magLog=-200;
250 #else
251  if(magLin==0) magLog=-200;
252 #endif
253  else magLog = CLAM_20log10(magLin);
254  complex[i].SetReal(magLog * re / magLin);
255  complex[i].SetImag(magLog * im / magLin);
256  }
257  flags.bComplex = true;
258  flags.bMagPhase = false;
259  }
260  if (HasMagBPF()) // WARNING: computational expensive operation
261  {
262  BPF &magBPF= GetMagBPF();
263  const int bpfSize=GetBPFSize();
264  for (i=0; i<bpfSize; i++)
265  {
266  TData magLin=magBPF.GetValueFromIndex(i);
267  TData magLog;
268 #ifdef CLAM_OPTIMIZE
269  if(magLin<0.00001f) magLog=-200;
270 #else
271  if(magLin==0) magLog=-200;
272 #endif
273  else magLog = CLAM_20log10(magLin);
274  magBPF.SetValue(i,magLog);
275  }
276  flags.bMagPhaseBPF = true;
277  flags.bMagPhase = false;
278  }
279  SetScale(EScale(EScale::eLog));
280 }
281 
282 
284 {
285  if(GetScale()==EScale::eLog)
286  {
287  int i;
288  SpecTypeFlags flags;
289  TSize specSize = GetSize();
290  if (HasMagBuffer())
291  {
292  DataArray &mag = GetMagBuffer();
293  for (i=0; i<specSize; i++)
294  {
295  if(mag[i]<=-200) mag[i]=0;
296  else mag[i]= log2lin(mag[i]);
297  }
298  }
299  if (HasPolarArray()) // WARNING: computational expensive operation
300  {
301  Array<Polar> &polar = GetPolarArray();
302  for (i=0; i<specSize; i++)
303  {
304  TData magLog = polar[i].Mag();
305  TData magLin;
306  if(magLog<=-200) magLin=0;
307  else magLin = log2lin(magLog);
308  polar[i].SetMag(magLin);
309  }
310  flags.bPolar = true;
311  flags.bMagPhase = false;
312  }
313  if (HasComplexArray()) // WARNING: computational expensive operation
314  {
315  Array<Complex> &complex = GetComplexArray();
316  for (i=0; i<specSize; i++)
317  {
318  TData re = complex[i].Real();
319  TData im = complex[i].Imag();
320  TData magLog = CLAM_sqrt(re*re + im*im);
321  TData magLin;
322  if(magLog<=-200) magLin=0;
323  else magLin = log2lin(magLog);
324  complex[i].SetReal(magLin * re / magLin);
325  complex[i].SetImag(magLin * im / magLin);
326  }
327  flags.bComplex = true;
328  flags.bMagPhase = false;
329  }
330  if (HasMagBPF()) // WARNING: computational expensive operation
331  {
332  BPF &magBPF = GetMagBPF();
333  int bpfSize=GetBPFSize();
334  for (i=0; i<bpfSize; i++)
335  {
336  TData magLog = magBPF.GetValueFromIndex(i);
337  TData magLin;
338  if(magLog<=-200) magLin=0;
339  else magLin = log2lin(magLog);
340  magBPF.SetValue(i,magLin);
341  }
342  flags.bMagPhaseBPF = true;
343  flags.bMagPhase = false;
344  }
345  SetScale(EScale(EScale::eLinear));
346 
347  }
348 }
349 
351 {
352  SpecTypeFlags tmpFlags;
353  GetType(tmpFlags);
354  if(tmpFlags.bMagPhase)
355  return GetMagBuffer()[pos];
356  if (tmpFlags.bMagPhaseBPF)
357  return GetMagBPF().GetValueFromIndex(pos);
358  if (tmpFlags.bPolar)
359  return GetPolarArray()[pos].Mag();
360  if (tmpFlags.bComplex)
361  return GetComplexArray()[pos].Mag();
362  CLAM_ASSERT(false, "Spectrum::GetMag: Spectrum no initialized");
363  return 0;
364 }
365 
367 {
368  SpecTypeFlags tmpFlags;
369  GetType(tmpFlags);
370  TIndex pos = IndexFromFreq(freq);
371  if (tmpFlags.bMagPhaseBPF)
372  return GetMagBPF().GetValue(freq);
373  if(tmpFlags.bMagPhase)
374  return GetMagBuffer()[pos];
375  if (tmpFlags.bPolar)
376  return GetPolarArray()[pos].Mag();
377  if (tmpFlags.bComplex)
378  return GetComplexArray()[pos].Mag();
379  CLAM_ASSERT(false, "Spectrum::GetMag: Spectrum no initialized");
380  return 0;
381 }
382 
384 {
385  SpecTypeFlags tmpFlags;
386  GetType(tmpFlags);
387  if(tmpFlags.bMagPhase)
388  return GetPhaseBuffer()[pos];
389  if (tmpFlags.bMagPhaseBPF)
390  return GetPhaseBPF().GetValueFromIndex(pos);
391  if (tmpFlags.bPolar)
392  return GetPolarArray()[pos].Ang();
393  if (tmpFlags.bComplex)
394  return GetComplexArray()[pos].Ang();
395  CLAM_ASSERT(false, "Spectrum::GetPhase: Spectrum no initialized");
396  return 0;
397 }
398 
400 {
401  SpecTypeFlags tmpFlags;
402  GetType(tmpFlags);
403  TIndex pos = IndexFromFreq(freq);
404  if (tmpFlags.bMagPhaseBPF)
405  return GetPhaseBPF().GetValue(freq);
406  if(tmpFlags.bMagPhase)
407  return GetPhaseBuffer()[pos];
408  if (tmpFlags.bPolar)
409  return GetPolarArray()[pos].Ang();
410  if (tmpFlags.bComplex)
411  return GetComplexArray()[pos].Ang();
412  CLAM_ASSERT(false, "Spectrum::GetPhase: Spectrum no initialized");
413  return 0;
414 }
415 
416 void Spectrum::SetMag(TIndex pos, TData newMag)
417 {
418  SpecTypeFlags tmpFlags;
419  GetType(tmpFlags);
420  if(tmpFlags.bMagPhase)
421  GetMagBuffer()[pos]=newMag;
422  if (tmpFlags.bMagPhaseBPF)
423  GetMagBPF().SetValue(pos,newMag);
424  if (tmpFlags.bPolar)
425  GetPolarArray()[pos].SetMag(newMag);
426  if (tmpFlags.bComplex){
427  TData tmpAng=GetComplexArray()[pos].Ang();
428  GetComplexArray()[pos].SetReal(newMag*CLAM_cos(tmpAng));
429  GetComplexArray()[pos].SetImag(newMag*CLAM_sin(tmpAng));}
430 }
431 
432 void Spectrum::SetMag(TData freq, TData newMag)
433 {
434  SetMag(IndexFromFreq(freq),newMag);
435 }
436 
437 void Spectrum::SetPhase(TIndex pos,TData newPhase)//inefficient Set, for efficiency work directly on the buffer
438 {
439  SpecTypeFlags tmpFlags;
440  GetType(tmpFlags);
441  if(tmpFlags.bMagPhase)
442  GetPhaseBuffer()[pos]=newPhase;
443  else if (tmpFlags.bMagPhaseBPF)
444  GetPhaseBPF().SetValue(pos,newPhase);
445  else if (tmpFlags.bPolar)
446  GetPolarArray()[pos].SetAng(newPhase);
447  else if (tmpFlags.bComplex){
448  TData tmpMag=GetComplexArray()[pos].Mag();
449  GetComplexArray()[pos].SetReal(tmpMag*CLAM_cos(newPhase));
450  GetComplexArray()[pos].SetImag(tmpMag*CLAM_sin(newPhase));
451  }
452 }
453 
454 void Spectrum::SetPhase(TData freq, TData newPhase)
455 {
456  SetPhase(IndexFromFreq(freq),newPhase);
457 }
458 
460 {
461  SynchronizeTo(tmpFlags,(*this));
462 }
463 
464 void Spectrum::SynchronizeTo(const SpecTypeFlags& tmpFlags,const Spectrum& in)
465 {
466  //if tmpFlags are set so different synchronizations are possible, the easiest one is chosen
467 
468  SpecTypeFlags currentFlags;
469  GetType(currentFlags);
470  int size = GetSize();
471 
472  if(tmpFlags.bMagPhase)
473  {
474  if(currentFlags.bPolar) MagPhase2Polar(in);
475  if(currentFlags.bComplex) MagPhase2Complex(in);
476  if(currentFlags.bMagPhaseBPF) MagPhase2BPF(in);
477  }
478  else if(tmpFlags.bComplex)
479  {
480  if(currentFlags.bPolar) Complex2Polar(in);
481  if(currentFlags.bMagPhase) Complex2MagPhase(in);
482  if(currentFlags.bMagPhaseBPF)
483  {
484  if(currentFlags.bMagPhase) MagPhase2BPF();
485  else
486  {
487  AddMagBuffer();
488  AddPhaseBuffer();
489  UpdateData();
490  GetMagBuffer().Resize(size);
491  GetPhaseBuffer().Resize(size);
492  GetMagBuffer().SetSize(size);
493  GetPhaseBuffer().SetSize(size);
494  Complex2MagPhase(in);
495  MagPhase2BPF();
496 
497  RemoveMagBuffer();
498  RemovePhaseBuffer();
499  UpdateData();
500  }
501  }
502  }
503  else if(tmpFlags.bPolar)
504  {
505  if(currentFlags.bComplex) Polar2Complex(in);
506  if(currentFlags.bMagPhase) Polar2MagPhase(in);
507  if(currentFlags.bMagPhaseBPF)
508  {
509  if(currentFlags.bMagPhase) MagPhase2BPF();
510  else
511  {
512  AddMagBuffer();
513  AddPhaseBuffer();
514  UpdateData();
515  GetMagBuffer().Resize(size);
516  GetPhaseBuffer().Resize(size);
517  GetMagBuffer().SetSize(size);
518  GetPhaseBuffer().SetSize(size);
519  Polar2MagPhase(in);
520  MagPhase2BPF();
521 
522  RemoveMagBuffer();
523  RemovePhaseBuffer();
524  UpdateData();
525  }
526  }
527  }
528  else if(tmpFlags.bMagPhaseBPF)
529  {
530  bool deleteMagPhase=false;
531  if(!currentFlags.bMagPhase)
532  {
533  deleteMagPhase=true;
534  AddMagBuffer();
535  AddPhaseBuffer();
536  UpdateData();
537  GetMagBuffer().Resize(size);
538  GetPhaseBuffer().Resize(size);
539  GetMagBuffer().SetSize(size);
540  GetPhaseBuffer().SetSize(size);
541  }
542  BPF2MagPhase(in);
543 
544  if(currentFlags.bPolar) MagPhase2Polar();
545  if(currentFlags.bComplex) MagPhase2Complex();
546  if(deleteMagPhase)
547  {
548  RemoveMagBuffer();
549  RemovePhaseBuffer();
550  UpdateData();
551  }
552  }
553 
554 
555 }
556 
557 
559 {
560  //if tmpFlags are set so different synchronizations are possible, the easiest one is chosen
561 
562  SpecTypeFlags tmpFlags;
563  in.GetType(tmpFlags);
564 
565  SynchronizeTo(tmpFlags,in);
566 
567 
568 
569 }
570 
572 
573 
575 {
576  ComplexToPolarCnv_ convert;
577  convert.ToPolar(in.GetComplexArray(), GetPolarArray());
578 }
579 
581 {
582  ComplexToPolarCnv_ convert;
583  convert.ToPolar(GetComplexArray(), GetPolarArray());
584 }
585 
587 {
588  ComplexToPolarCnv_ convert;
589  convert.ToComplex(in.GetPolarArray(),GetComplexArray());
590 }
591 
593 {
594  ComplexToPolarCnv_ convert;
595  convert.ToComplex(GetPolarArray(),GetComplexArray());
596 }
597 
598 void Spectrum::Polar2MagPhase(const Array<Polar>& polarArray,DataArray& magBuffer, DataArray& phaseBuffer)
599 {
600  int size = GetSize();
601  for (int i=0; i<size; i++)
602  {
603  magBuffer[i] = polarArray[i].Mag();
604  phaseBuffer[i] = polarArray[i].Ang();
605  }
606 }
607 
609 {
610  Polar2MagPhase(in.GetPolarArray(),GetMagBuffer(),GetPhaseBuffer());
611 }
612 
614 {
615  Polar2MagPhase(GetPolarArray(),GetMagBuffer(),GetPhaseBuffer());
616 }
617 
618 void Spectrum::Complex2MagPhase(const Array<Complex>& complexArray, DataArray& magBuffer, DataArray& phaseBuffer)
619 {
620  int size = GetSize();
621  for (int i=0; i<size; i++)
622  {
623  magBuffer[i] = complexArray[i].Mag();
624  phaseBuffer[i] = complexArray[i].Ang();
625  }
626 }
627 
629 {
630  Complex2MagPhase(in.GetComplexArray(),GetMagBuffer(),GetPhaseBuffer());
631 }
632 
634 {
635  Complex2MagPhase(GetComplexArray(),GetMagBuffer(),GetPhaseBuffer());
636 }
637 
638 void Spectrum::MagPhase2Polar(const DataArray& magBuffer,const DataArray& phaseBuffer,Array<Polar>& polarArray)
639 {
640  int size = GetSize();
641  for (int i=0; i<size; i++)
642  {
643  polarArray[i].SetMag(magBuffer[i]);
644  polarArray[i].SetAng(phaseBuffer[i]);
645  }
646 }
647 
649 {
650  MagPhase2Polar(in.GetMagBuffer(),in.GetPhaseBuffer(),GetPolarArray());
651 
652 }
653 
655 {
656  MagPhase2Polar(GetMagBuffer(),GetPhaseBuffer(),GetPolarArray());
657 
658 }
659 
660 void Spectrum::MagPhase2Complex(const DataArray& magBuffer,const DataArray& phaseBuffer,Array<Complex>& complexArray)
661 {
662  int size = GetSize();
663  /* Xamat: I think this is not necessary, check in tests
664  complexArray.Resize(size);
665  complexArray.SetSize(size);*/
666  for (int i=0; i<size; i++)
667  {
668  complexArray[i].SetReal(magBuffer[i]*CLAM_cos(phaseBuffer[i]));
669  complexArray[i].SetImag(magBuffer[i]*CLAM_sin(phaseBuffer[i]));
670  }
671 }
672 
674 {
675  MagPhase2Complex(in.GetMagBuffer(), in.GetPhaseBuffer(),GetComplexArray());
676 }
677 
679 {
680  MagPhase2Complex(GetMagBuffer(), GetPhaseBuffer(),GetComplexArray());
681 }
682 
683 void Spectrum::MagPhase2BPF(const DataArray& magBuffer, const DataArray& phaseBuffer, BPF& magBPF, BPF& phaseBPF)
684 {
685  int size = GetSize();
686  CLAM_ASSERT(size == GetBPFSize(),
687  "Spectrum::MagPhase2BPF(): BPFSize and MagPhase size differ.");
688 
689  DataArray freqBuffer(size);
690  TData delta = GetSpectralRange()/(size-1);
691 
692  ConvertToBPF( magBPF, TData(0), delta, magBuffer );
693  ConvertToBPF( phaseBPF, TData(0), delta, phaseBuffer );
694 }
695 
696 
698 {
699  MagPhase2BPF(in.GetMagBuffer(),in.GetPhaseBuffer(),GetMagBPF(),GetPhaseBPF());
700 }
701 
703 {
704  MagPhase2BPF(GetMagBuffer(),GetPhaseBuffer(),GetMagBPF(),GetPhaseBPF());
705 }
706 
707 void Spectrum::BPF2MagPhase( const BPF& magBPF, const BPF& phaseBPF, DataArray& magBuffer, DataArray& phaseBuffer)
708 {
709  int i;
710  TData freq;
711  int size = GetSize();
712  TData delta = GetSpectralRange()/(size-1);
713  for(i=0; i<size; i++){
714  freq = i*delta;
715  magBuffer[i] = magBPF.GetValue(freq); // interpolation
716  phaseBuffer[i]= phaseBPF.GetValue(freq);
717  }
718 }
719 
721 {
722  BPF2MagPhase(in.GetMagBPF(),in.GetPhaseBPF(),GetMagBuffer(),GetPhaseBuffer());
723 }
724 
726 {
727  BPF2MagPhase(GetMagBPF(),GetPhaseBPF(),GetMagBuffer(),GetPhaseBuffer());
728 }
729 
730 
731 
732 int Spectrum::GetSize() const
733 {
734  const int size= GetprSize();
735 
737  if(HasMagBuffer() && GetMagBuffer().Size())
738  CLAM_ASSERT(GetMagBuffer().Size() == size,
739  "Spectrum::GetSize(): Mag size and Size mismatch.");
740  if(HasPhaseBuffer() && GetPhaseBuffer().Size())
741  CLAM_ASSERT(GetPhaseBuffer().Size() == size,
742  "Spectrum::GetSize(): Phase size and Size mismatch.");
743  if(HasComplexArray() && GetComplexArray().Size())
744  CLAM_ASSERT(GetComplexArray().Size() == size,
745  "Spectrum::GetSize(): Complex size and Size mismatch.");
746  if(HasPolarArray() && GetPolarArray().Size())
747  CLAM_ASSERT(GetPolarArray().Size() == size,
748  "Spectrum::GetSize(): Polar size and Size mismatch.");
749  if (!HasprBPFSize()) {
750  if(HasMagBPF() && GetMagBPF().Size())
751  CLAM_ASSERT(GetMagBPF().Size() == size,
752  "Spectrum::GetSize(): MagBPF size and Size mismatch.");
753  if(HasPhaseBPF() && GetPhaseBPF().Size())
754  CLAM_ASSERT(GetPhaseBPF().Size() == size,
755  "Spectrum::GetSize(): PhaseBPF size and Size mismatch.");
756  }
758 
759  return size;
760 }
761 
762 
763 void Spectrum::SetSize(int newSize)
764 {
765  SetprSize(newSize);
766 
767  if(HasMagBuffer()){
768  GetMagBuffer().Resize(newSize);
769  GetMagBuffer().SetSize(newSize);}
770  if(HasPhaseBuffer()){
771  GetPhaseBuffer().Resize(newSize);
772  GetPhaseBuffer().SetSize(newSize);}
773  if (HasPolarArray()){
774  GetPolarArray().Resize(newSize);
775  GetPolarArray().SetSize(newSize);}
776  if (HasComplexArray()){
777  GetComplexArray().Resize(newSize);
778  GetComplexArray().SetSize(newSize);}
779  if (!HasprBPFSize()) {
780  if (HasMagBPF()){
781  GetMagBPF().Resize(newSize);
782  GetMagBPF().SetSize(newSize);}
783  if (HasPhaseBPF()) {
784  GetPhaseBPF().Resize(newSize);
785  GetPhaseBPF().SetSize(newSize);}
786  }
787 }
788 
790 {
791  const int bpfsize= HasprBPFSize() ? GetprBPFSize() : GetSize();
792 
794  CLAM_ASSERT(! (HasMagBPF() && GetMagBPF().Size() && GetMagBPF().Size() != bpfsize) ,
795  "Spectrum::GetBPFSize(): MagBPF size and BPFSize mismatch.");
796  CLAM_ASSERT(!(HasPhaseBPF() && GetPhaseBPF().Size() && GetPhaseBPF().Size() != bpfsize),
797  "Spectrum::GetBPFSize(): PhaseBPF size and BPFSize mismatch.");
799 
800  return bpfsize;
801 }
802 
804 {
805  if (s != GetprSize()) {
806  AddprBPFSize();
807  UpdateData();
808  SetprBPFSize(s);
809  }
810  else {
811  RemoveprBPFSize();
812  UpdateData();
813  }
814 
815  if (HasMagBPF() && HasPhaseBPF())
816  {
817  GetMagBPF().Resize(s);
818  GetMagBPF().SetSize(s);
819  GetPhaseBPF().Resize(s);
820  GetPhaseBPF().SetSize(s);
821  }
822 }
823 
825 {
826  SpecTypeFlags previousFlags;
827  GetType(previousFlags );
828  SpecTypeFlags tmpFlags;
829 
830  tmpFlags.bComplex = previousFlags.bComplex | newFlags.bComplex;
831  tmpFlags.bPolar = previousFlags.bPolar | newFlags.bPolar;
832  tmpFlags.bMagPhase = previousFlags.bMagPhase | newFlags.bMagPhase;
833  tmpFlags.bMagPhaseBPF = previousFlags.bMagPhaseBPF | newFlags.bMagPhaseBPF;
834 
835  SetType(tmpFlags);
836  SynchronizeTo(previousFlags);
837  SetType(newFlags);
838 }
839 
840 
842 {
843  f.bMagPhaseBPF = HasMagBPF() && HasPhaseBPF();
844  f.bMagPhase = HasMagBuffer() && HasPhaseBuffer();
845  f.bPolar = HasPolarArray();
846  f.bComplex = HasComplexArray();
847 }
848 
850 {
851  return Round(freq*((GetSize()-1)/GetSpectralRange()));
852 }
853