cannam@0: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
cannam@0: 
cannam@0: /*
cannam@0:     QM DSP library
cannam@0:     Centre for Digital Music, Queen Mary, University of London.
cannam@0:     This file Copyright 2006 Chris Cannam.
Chris@84: 
Chris@84:     This program is free software; you can redistribute it and/or
Chris@84:     modify it under the terms of the GNU General Public License as
Chris@84:     published by the Free Software Foundation; either version 2 of the
Chris@84:     License, or (at your option) any later version.  See the file
Chris@84:     COPYING included with this distribution for more information.
cannam@0: */
cannam@0: 
cannam@0: #ifndef _WINDOW_H_
cannam@0: #define _WINDOW_H_
cannam@0: 
cannam@0: #include <cmath>
cannam@0: #include <iostream>
cannam@0: #include <map>
Chris@157: #include <vector>
cannam@0: 
cannam@0: enum WindowType {
cannam@0:     RectangularWindow,
cannam@0:     BartlettWindow,
cannam@0:     HammingWindow,
cannam@0:     HanningWindow,
cannam@0:     BlackmanWindow,
Chris@157:     BlackmanHarrisWindow,
Chris@109: 
Chris@109:     FirstWindow = RectangularWindow,
Chris@157:     LastWindow = BlackmanHarrisWindow
cannam@0: };
cannam@0: 
Chris@152: /**
Chris@152:  * Various shaped windows for sample frame conditioning, including
Chris@152:  * cosine windows (Hann etc) and triangular and rectangular windows.
Chris@152:  */
cannam@0: template <typename T>
cannam@0: class Window
cannam@0: {
cannam@0: public:
cannam@0:     /**
Chris@109:      * Construct a windower of the given type and size. 
Chris@109:      *
Chris@109:      * Note that the cosine windows are periodic by design, rather
Chris@109:      * than symmetrical. (A window of size N is equivalent to a
Chris@109:      * symmetrical window of size N+1 with the final element missing.)
cannam@0:      */
Chris@157:     Window(WindowType type, int size) : m_type(type), m_size(size) { encache(); }
cannam@0:     Window(const Window &w) : m_type(w.m_type), m_size(w.m_size) { encache(); }
cannam@0:     Window &operator=(const Window &w) {
cannam@0: 	if (&w == this) return *this;
cannam@0: 	m_type = w.m_type;
cannam@0: 	m_size = w.m_size;
cannam@0: 	encache();
cannam@0: 	return *this;
cannam@0:     }
cannam@26:     virtual ~Window() { delete[] m_cache; }
cannam@0:     
cannam@0:     void cut(T *src) const { cut(src, src); }
cannam@55:     void cut(const T *src, T *dst) const {
Chris@157: 	for (int i = 0; i < m_size; ++i) dst[i] = src[i] * m_cache[i];
cannam@0:     }
cannam@0: 
cannam@0:     WindowType getType() const { return m_type; }
Chris@157:     int getSize() const { return m_size; }
Chris@157: 
Chris@157:     std::vector<T> getWindowData() const {
Chris@157:         std::vector<T> d;
Chris@157:         for (int i = 0; i < m_size; ++i) {
Chris@157:             d.push_back(m_cache[i]);
Chris@157:         }
Chris@157:         return d;
Chris@157:     }
cannam@0: 
cannam@0: protected:
cannam@0:     WindowType m_type;
Chris@157:     int m_size;
cannam@0:     T *m_cache;
cannam@0:     
cannam@0:     void encache();
cannam@0: };
cannam@0: 
cannam@0: template <typename T>
cannam@0: void Window<T>::encache()
cannam@0: {
Chris@157:     int n = m_size;
cannam@0:     T *mult = new T[n];
Chris@157:     int i;
cannam@0:     for (i = 0; i < n; ++i) mult[i] = 1.0;
cannam@0: 
cannam@0:     switch (m_type) {
cannam@0: 		
cannam@0:     case RectangularWindow:
Chris@109:         for (i = 0; i < n; ++i) {
Chris@109:             mult[i] = mult[i] * 0.5;
cannam@0: 	}
cannam@0: 	break;
cannam@0: 	    
cannam@0:     case BartlettWindow:
Chris@109:         if (n == 2) {
Chris@109:             mult[0] = mult[1] = 0; // "matlab compatible"
Chris@109:         } else if (n == 3) {
Chris@109:             mult[0] = 0;
Chris@109:             mult[1] = mult[2] = 2./3.;
Chris@109:         } else if (n > 3) {
Chris@109:             for (i = 0; i < n/2; ++i) {
Chris@109:                 mult[i] = mult[i] * (i / T(n/2));
Chris@109:                 mult[i + n - n/2] = mult[i + n - n/2] * (1.0 - (i / T(n/2)));
Chris@109:             }
cannam@0: 	}
cannam@0: 	break;
cannam@0: 	    
cannam@0:     case HammingWindow:
Chris@109:         if (n > 1) {
Chris@109:             for (i = 0; i < n; ++i) {
Chris@109:                 mult[i] = mult[i] * (0.54 - 0.46 * cos(2 * M_PI * i / n));
Chris@109:             }
cannam@0: 	}
cannam@0: 	break;
cannam@0: 	    
cannam@0:     case HanningWindow:
Chris@109:         if (n > 1) {
Chris@109:             for (i = 0; i < n; ++i) {
Chris@109:                 mult[i] = mult[i] * (0.50 - 0.50 * cos(2 * M_PI * i / n));
Chris@109:             }
cannam@0: 	}
cannam@0: 	break;
cannam@0: 	    
cannam@0:     case BlackmanWindow:
Chris@109:         if (n > 1) {
Chris@109:             for (i = 0; i < n; ++i) {
Chris@109:                 mult[i] = mult[i] * (0.42 - 0.50 * cos(2 * M_PI * i / n)
Chris@109:                                      + 0.08 * cos(4 * M_PI * i / n));
Chris@109:             }
cannam@0: 	}
cannam@0: 	break;
Chris@157: 	    
Chris@157:     case BlackmanHarrisWindow:
Chris@157:         if (n > 1) {
Chris@157:             for (i = 0; i < n; ++i) {
Chris@157:                 mult[i] = mult[i] * (0.35875
Chris@157:                                      - 0.48829 * cos(2 * M_PI * i / n)
Chris@157:                                      + 0.14128 * cos(4 * M_PI * i / n)
Chris@157:                                      - 0.01168 * cos(6 * M_PI * i / n));
Chris@157:             }
Chris@157: 	}
Chris@157: 	break;
cannam@0:     }
Chris@109: 	   
cannam@0:     m_cache = mult;
cannam@0: }
cannam@0: 
cannam@0: #endif