paradigma 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

paradigma/ppg/hr_functions/Long_TFD_JOT.m

@@ -0,0 +1,37 @@
+%% Implementation using the toolbox of J. O'Toole
+ 
+% Only the essential code is used. The function nonsep_gdtfd is code from
+% the toolbox of J. O'Toole: Copyright © 2014, John M. O  Toole, University College Cork. All rights reserved.
+function HR_smooth_tfd = Long_TFD_JOT(rel_ppg_tfd, MA, fs, kern_type, kern_params)
+
+tfd = nonsep_gdtfd(rel_ppg_tfd, kern_type, kern_params);   % for now the wigner ville distribution but one could also use the smoothed pseudo WVD --> returns matrix of size NxN 
+
+if MA.value == 1
+    input = tfd';            
+    tfd = filtfilt(MA.FC,1,input);
+    tfd = tfd.';
+end
+
+%%----- Get time and frequency axis for tfd-----%%
+[~,M]=size(tfd);
+Ntime=size(tfd,1);   
+    
+ntime=1:Ntime; ntime=ntime./fs-1/fs;       % time array
+Mh=ceil(M);
+k=linspace(0,0.5,Mh);
+k=k.*fs;                                   % frequency array
+
+%%---Estimate HR using same approach as for given tfd----%%
+[~, k_idx] = max(tfd, [], 1);
+
+
+count = 0;
+
+for i = 2:2:length(rel_ppg_tfd)/fs-4            % starting at 2 and ending at length -4 to discard the first and last 2 sec of the WVD which are influenced by boundary effects
+    count = count + 1;
+    rel_wvd_idx = ntime>=i & ntime<i+2;
+    HR_smooth_tfd(count,1) = 60*mean(k(k_idx(rel_wvd_idx))); 
+
+end
+
+end

paradigma/ppg/hr_functions/PPG_TFD_HR.m

@@ -0,0 +1,59 @@
+function HR_smooth_tfd = PPG_TFD_HR(rel_ppg_tfd, tfd_length, MA, fs, kern_type, kern_params)
+    % Function to estimate the HR using a particular TFD method, such as WVD,
+    % SPWVD or other kernel methods over segments of 30 s. If the remaining segment
+    % length is longer than 30 s it is calculated over the entire length to
+    % include all data into the analysis. 
+    
+    % Input:
+    % - rel_ppg_wvd: ppg signal with an addition of 2s on both sides to
+    % overcome boundary effects
+    % - tfd_length: set the length to calculate time frequency distribution
+    % - MA: struct containing the information to perform a moving average
+    % filter over the TFD to overcome fundamental frequency switching
+    % - fs: sample frequency
+    % - kern_type: specified as a string such as 'wvd' for the wigner ville
+    % distribution
+    % - kern_params: kernel specifications, not relevant for 'wvd', but they
+    % are for 'spwvd', 'swvd' etc.
+    
+    % Output:
+    % - HR_smooth_tfd: array containing an estimation of the HR for every 2 s
+    % of the relevant epoch (without the additional 2 s on both sides)
+    
+    if ~exist('kern_params', 'var')
+        kern_params = {};     % Function also works without having imu_label --> then based on ppg_prob alone!
+    end
+    
+    edge_add = 4;       % adding an additional 4 sec (2 s to both sides) to overcome boundary effects/discontinuities of the WVD, in SPWVD this effect is already diminished due to a double kernel function
+    epoch_length = tfd_length + edge_add;
+    segment_length = (length(rel_ppg_tfd)-edge_add*fs)/fs;              % substract the 4 added sec to obtain the original segment length
+    
+    if segment_length > epoch_length
+        n_segments = floor(segment_length/tfd_length); %% Dit moet aangepast worden!!
+    else 
+        n_segments = 1;  % for HR segments which are shorter than 30 s due to uneven start and end of the segment which can make the segment 28 s if 1 s is substracted
+    end
+    
+    ppg_segments = cell(n_segments,1);
+    
+    for i = 1:n_segments                        % Split segments in 30 s PPG epochs 
+    
+        if i ~= n_segments          
+            ppg_segments{i} = rel_ppg_tfd(1 + (i-1)*tfd_length*fs: (i*tfd_length+edge_add)*fs);
+    
+        else 
+            
+            ppg_segments{i} = rel_ppg_tfd(1 + (i-1)*tfd_length*fs:end);
+    
+        end
+    
+    end
+    
+    HR_smooth_tfd = [];
+    
+    for j = 1:n_segments                    % Calculate the HR
+        ppg = ppg_segments{j};
+        HR_tfd = Long_TFD_JOT(ppg, MA, fs, kern_type, kern_params);
+        HR_smooth_tfd = [HR_smooth_tfd; HR_tfd];
+    end
+    

paradigma/ppg/hr_functions/TFD toolbox JOT/.gitignore

@@ -0,0 +1,4 @@
+todo_list.org
+full_TFDs/full_gdtfd_testing_version.m
+notes_decimated_GDTFD_algorithms.org
+docs_pdf_readme/

paradigma/ppg/hr_functions/TFD toolbox JOT/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Change Log
+All notable changes to this project will be documented in this file. Project started
+2014-04-22 but this log started 2017-05-30, after version 0.2.3. More details can be found
+in the git logs.
+
+
+## unreleased
+### Changed 
+- implemented modified-B distribution in 'nonsep' section,
+  e.g. tf=full_tfd(x,'nonsep',{'mb',0.01}); but is better to use lag-independent version,
+  i.e. tf=full_tfd(x,'LI,{length(x)-1,'cosh',0.01});
+### Removed
+### Fixed
+- input argument (Ntime) when calling LI kernel from full_tfd.m (was incorrectly passing
+  Nfreq)
+- bug fix in `gen_lag_kern.m` and `gen_Doppler_kern.m` for windows `gauss`, `cosh`, `tukey` as
+default value was 0; now use Matlab will use default value
+- missing `shiftWin` function (centres window) in `gen_lag_kern.m` and
+`gen_Doppler_kern.m` (only used if 5 parameters in window cell); now added
+### Added
+- this CHANGELOG.md!
+- windows: `blackmanharris`, `chebwin`, and `nuttall` (in `get_window.m`)
+

paradigma/ppg/hr_functions/TFD toolbox JOT/LICENCE.md

@@ -0,0 +1,27 @@
+Copyright (c) 2014, John M. O' Toole, University College Cork
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+  Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+  Neither the name of the University College Cork nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

paradigma/ppg/hr_functions/TFD toolbox JOT/README.md

@@ -0,0 +1,251 @@
+# Fast and Memory-Efficient Algorithms for Quadratic Time–Frequency Distributions
+
+A collection of M-files to compute time–frequency distributions from the quadratic class
+[[1] and [2]](#references). Memory and computational load is limited by controlling the level of over-sampling for the TFD. Oversampling in the TFD is proportional to signal length and bandwidth of the Doppler–lag kernel. Algorithms are optimised to four kernel types: nonseparable, separable, lag-independent, and Doppler-independent kernels.  
+
+Also included are algorithms to compute decimated, or sub-sampled, TFDs. Again, these
+algorithms are specific to the four kernel types but compute approximate TFDs by a process
+of decimatation.  
+
+Requires Matlab or Octave (programming environments).  
+
+Latest version available at [memeff_TFDs homepage](http://otoolej.github.io/code/memeff_TFDs/).
+
+
+# Contents
+- [quick start](#quick-start)
+- [description](#description)
+- [files](#files)
+- [computational load](#computational-load)
+- [requirements](#requirements)
+- [test computer setup](#test-computer-setup)
+- [licence](#licence)
+- [references](#references)
+- [contact](#contact)
+
+
+# quick start
+First, add paths using the `load_curdir` function:
+```matlab
+  >> load_curdir;
+```
+
+# description
+
+There are two sets of TFD algorithms: one set computes oversampled TFDs and the other
+set computes decimated (sub-sampled or undersampled) TFDs. The first set, for computing
+oversampled TFDs, has four algorithms for specific kernel types, namely the
+- non-separable kernel,
+- separable kernel,
+- Doppler-independent (DI) kernel,
+- and lag-independent (LI) kernel.
+
+The function to generate these oversampled TFDs is `full_tfd.m`. The following
+examples, using a test signal, illustrates usage:
+
+```matlab
+  % generate test signal:
+  N=512;
+  x=gen_LFM(N,0.1,0.3) + gen_LFM(N,0.4,0.04);
+
+  % nonseparable kernel (Choi-Williams kernel):
+  tf=full_tfd(x,'nonsep',{'cw',10});
+  figure(1); clf; vtfd(tf,x);
+  
+  % separable kernel:
+  tf=full_tfd(x,'sep',{{51,'hann'},{101,'hann'}},256,256);
+  figure(2); clf; vtfd(tf,x);
+  
+  % Doppler-independent kernel:
+  tf=full_tfd(x,'DI',{101,'hann'},[],256);
+  figure(3); clf; vtfd(tf,x);
+  
+  % lag-independent kernel:
+  tf=full_tfd(x,'LI',{51,'hann'},256,[]);
+  figure(4); clf; vtfd(tf,x);
+```
+![Examples of oversampled TFDs](pics/full_TFDs_examples.png)
+Type `help full_tfd` for more details.
+
+Likewise, the algorithms for decimated TFDs are specific to the four kernel types. The
+function `dec_tfd` computes the decimated TFDs, as the following examples show:
+
+```matlab
+  N=1024; Ntime=64; Nfreq=128;                                              
+  a=2; b=2;                                                       
+  ni=[100:2:900]; ki=[150:2:850];                                 
+                                                                  
+  x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);                        
+                                                                  
+  % non-separable kernel:                                         
+  c=dec_tfd(x,'nonsep',{'cw',100},N,N,a*4,b*4);                       
+  figure(1); clf; vtfd(c,x);                                      
+                                                                  
+  % separable kernel:                                             
+  c=dec_tfd(x,'sep',{{51,'hann'},{101,'hann'}},Ntime,Nfreq,a,b);    
+  figure(2); clf; vtfd(c,x);                                      
+                                                                  
+  % Doppler-independent kernel:                                   
+  c=dec_tfd(x,'DI',{101,'hann'},N,Nfreq,ni,b);                      
+  figure(3); clf; vtfd(c,x,1,ni);                                 
+                                                                  
+  % lag-independent kernel:                                       
+  c=dec_tfd(x,'LI',{51,'hann'},Ntime,N,a,ki);                       
+  figure(4); clf; vtfd(c,x,1,[],ki./(N*2));                       
+```
+![Examples of decimated TFDs](pics/decimated_TFDs_examples.png)
+
+Type `help dec_tfd` for more details on this function.
+
+
+# files
+All Matlab files (.m files) have a description and an example in the header. To read this
+header, type `help <filename.m>` in Matlab.  Directory structure is as follows: 
+```
+├── common             # directory: files to generate kernel functions
+├── decimated_TFDs     # directory: files to generate decimated TFD for the 4 kernel types
+├── dec_tfd.m          # file: compute decimated TFDs
+├── full_tfd.m         # file: compute oversampled TFDs
+├── full_TFDs          # directory: files to generate oversampled TFD for the 4 kernel types
+├── LICENCE.md         # file: licence file
+├── load_curdir.m      # file: adds paths for matlab/octave
+├── README.md          # file: this README file
+└── utils              # directory: miscellaneous files
+```
+
+
+# computational load
+
+The computational load is measured in terms of the number of FFTs required to compute the
+TFD. Memory load is measured as the total memory required to compute and store the
+TFD. The real-valued signal (i.e. input signal) is of length N.
+
+Computational load for the oversampled TFDs (using `full_tfd.m`) is as follows for the
+four kernel types:
+
+| kernel-type   | computational load           | memory (real-valued points) |
+|---------------|------------------------------|-----------------------------|
+| non-separable | 3N²/2 log₂ N                 | N²                          |
+| LI            | NNtime/2 log₂ Ntime          | Ntime × N                   |
+| DI            | NNfreq/2 log₂ Nfreq          | N × Nfreq                   |
+| separable     | Pₕ(N log₂N +Ntime log₂Ntime) | Ntime × Nfreq               |
+|               | + NtimeNfreq/2 log₂ Nfreq    |                             |
+
+assuming the FFT of length-N signal requires Nlog₂N computations and using the notation:
+
+| symbol | explanation                                                 |
+|--------|-------------------------------------------------------------|
+| N      | length of signal                                            |
+| Ntime  | length of TFD in time direction                             |
+| Nfreq  | length of TFD in frequency direction                        |
+| Pₕ     | Pₕ = P/2, where P is the length of the lag window           |
+
+And for the decimated TFDs (using `dec_tfd.m`):
+
+| kernel-type   | computational load           | memory (real-valued points) | grid     |
+|---------------|------------------------------|-----------------------------|----------|
+| non-separable | N²/2 log₂ N + LJ/2 log₂ J    | L × J                       | ρ[an,bn] |
+| LI            | VLtime/2 log₂ Ltime          | Ltime × V                   | ρ[an,kᵢ] |
+| DI            | UJfreq/2 log₂ Jfreq          | U × Jfreq                   | ρ[nᵢ,bk] |
+| separable     | JfreqN/2 log₂N               | Ltime × Jfreq               | ρ[an,bn] |
+|               | + LtimeJfreq log₂ LtimeJfreq |                             |          |
+   
+using the extra notation:
+
+| symbol | explanation                                                 |
+|--------|-------------------------------------------------------------|
+| U      | length of sequence nᵢ {nᵢ for 1<=i<=U}, U<=N and 0<=nᵢ<=N-1   |
+| V      | length of sequence kᵢ {kᵢ for 1<=i<=V}, V<=N and 0<=kᵢ<=N-1   |
+| J      | N/b, b is decimation integer in frequency direction         |
+| L      | N/a, a is decimation integer in time direction              |
+| Jfreq  | Nfreq/b, b is decimation integer in frequency direction     |
+| Ltime  | Ntime/a, a is decimation integer in time direction          |
+
+
+# requirements
+Either Matlab (R2012 or newer,
+[Mathworks website](http://www.mathworks.co.uk/products/matlab/)) or Octave (v3.6 or
+newer, [Octave website](http://www.gnu.org/software/octave/index.html), with the
+'octave-signal' add-on package).  
+
+
+# test computer setup
+- hardware:  Intel(R) Xeon(R) CPU E5-1603 0 @ 2.80GHz; 8GB memory.
+- operating system: Ubuntu GNU/Linux x86_64 distribution (Trusty Tahr, 14.04), with Linux
+  kernel 3.13.0-27-generic
+- software: Octave 3.8.1 (using Gnuplot 4.6 patchlevel 4), with 'octave-signal' toolbox
+  and Matlab (R2009b, R2012a, and R2013a)
+
+---
+
+# licence
+
+```
+Copyright (c) 2014, John M. O' Toole, University College Cork
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+  Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+  Neither the name of the University College Cork nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+
+# references
+
+1. J.M. O' Toole and B. Boashash, “Memory Efficient Algorithms for Quadratic TFDs”,
+   Chapter 6.6; in Time–Frequency Signal Processing and Analysis: A
+   Comprenhensive Reference, Second Edition, Academic Press, pp. 374–385, 2016 (ISBN: 9780123984999).
+
+2. J.M. O' Toole and B. Boashash, "Fast and memory-efficient algorithms for computing
+   quadratic time–frequency distributions", Applied and Computational Harmonic Analysis,
+   vol. 35, no. 2, pp. 350–358, 2013.
+
+3. J.M. Oʼ Toole, M. Mesbah, and B. Boashash, “Improved discrete definition of quadratic
+   time–frequency distributions,” IEEE Transactions on Signal Processing, vol. 58,
+   Feb. 2010, pp. 906-911.
+
+4. J.M. O' Toole, M. Mesbah, and B. Boashash, "A New Discrete Analytic Signal for Reducing
+   Aliasing in the Discrete Wigner-Ville Distribution", IEEE Transactions on Signal
+   Processing, vol. 56, no. 11, pp. 5427-5434, Nov. 2008.
+
+5. J.M. Oʼ Toole, M. Mesbah, and B. Boashash, “Algorithms for discrete quadratic
+   time–frequency distributions,” WSEAS Transactions on Signal Processing, vol. 4,
+   May. 2008, pp. 320-329.
+
+
+---
+
+# contact
+
+John M. O' Toole
+
+Neonatal Brain Research Group,  
+Irish Centre for Maternal and Child Health Research [(INFANT)](https://www.infantcentre.ie/),  
+Department of Paediatrics and Child Health,  
+Cork University Hospital,
+University College Cork,  
+Ireland
+
+- email: jotoole -AT- ucc DOT ie
+

paradigma/ppg/hr_functions/TFD toolbox JOT/common/gen_Doppler_kern.m

@@ -0,0 +1,142 @@
+%-------------------------------------------------------------------------------
+% gen_Doppler_kern: smoothing window for Doppler-kernel G1[l]; checks paramaters
+%
+% Syntax: [G1,Q,Qh_floor,Ntime]=gen_Doppler_kern(win_params,N,Ntime)
+%
+%  Input:
+%       win_params - cell of {win_length,win_type,[win_param],[Doppler_or_time]}
+%                     e.g. {11,'hamm',0,1}
+%                     the parameter 'Doppler_or_time' is either:
+%                       0 = to define window in the time-domain
+%                       1 = to define window in the Doppler-domain (default)
+%       N          - length of signal
+%       Ntime      - number of sample points in the time direction
+%
+%  Ouput:
+%       G1           - Doppler function G_1(1/(QT))
+%       Q            - length of G1
+%       Ntime        - returns Ntime as it may be adjusted from input
+%
+%  See also: GEN_LAG_KERN, GEN_DOPPLER_LAG_KERN, GET_WINDOW, PADWIN
+%
+%  Example:
+%       G1=gen_Doppler_kern({111,'cosh',0.1,1},128,512);
+%       plot(real(G1));
+%
+% 
+% IF window is defined in doppler domain:
+%     window function G_1(l/NT) is length Q
+% OR if window is defined in time domain:
+%     window function g_1(nT) is length-Q, and then zero-padded 
+%     to the doppler domain where G_1(l/NT) is length N
+% ENDIF 
+
+% John M. O' Toole, University College Cork
+% Started: 16-04-2014
+%
+% last update: Time-stamp: <2021-08-24 17:42:57 (otoolej)>
+%-------------------------------------------------------------------------------
+function [G1,Q,Ntime,G1_pad]=gen_Doppler_kern(win_params,N,Ntime)
+if(nargin<3 || isempty(Ntime)), Ntime=[]; end
+
+
+DBplot=0;
+
+
+%---------------------------------------------------------------------
+% 1. make sure parameters are ok
+%---------------------------------------------------------------------
+Q=win_params{1};
+% window length can not be greater than N:
+if(Q>N)
+    warning('length of g2 too long: chopping down length N');
+    Q=N;
+end
+% force window length to be odd-value:
+if(Q/2==fix(Q/2))
+    Q=Q-1; 
+    warning(['Forcing Q to be odd. Q is now Q=',num2str(Q)]);
+end
+Qh_floor=floor(Q/2);
+
+
+l=length(win_params);
+if( l<2 ) 
+  error('Need at least two window parameters'); 
+end
+if(isempty(Ntime)), Ntime=Q+1; end
+
+if(Ntime<(Q+1))
+    warning('Ntime is too short: increasing length to (Q+1)');
+    Ntime=Q+1;
+end
+
+% force Ntime to be even
+if(rem(Ntime,2)), 
+    Ntime=Ntime+1; 
+    warning(['Forcing Ntime to be even. Ntime is now Ntime=',num2str(Ntime)]);
+end
+
+
+
+%---------------------------------------------------------------------
+% 2. call function to generate window
+%---------------------------------------------------------------------
+win_type=win_params{2}; 
+if( l>=3 ) win_extra_param=win_params{3}; else, win_extra_param=[]; end
+if( l>3 )  win_dft_param=win_params{4}; else, win_dft_param=1; end
+
+
+% if define in Doppler domain:
+if(win_dft_param==1)
+    G1=get_window(Q,win_type,win_extra_param);
+    G1=G1(:);
+
+    G1_pad=padWin(G1,Ntime);
+    
+    
+else
+    % or defining window in the time-domain:
+    g1=get_window(Q,win_type,win_extra_param,0);
+    g1=padWin(g1,N);
+    G1_length=N;
+
+    G1=real( fft(g1) ); 
+    G1=G1./G1(1);
+    Ntime=N; Q=N;
+end
+
+
+%---------------------------------------------------------------------
+% 3. [OPTIONAL] post-process window
+%---------------------------------------------------------------------
+% a. if normalizing window:
+if(length(win_params)>4)
+  if(strcmpi(win_params{5},'y')==1)
+    G1=G1./sum(G1);
+  end
+end
+
+% b. if (time) reversing window
+if(length(win_params)>5 )
+  G1=shiftWin(G1);
+  G1_pad=shiftWin(G1_pad);
+end
+
+
+if(DBplot)
+    figure(20); clf; hold all;
+    if(exist('G1_pad','var'))
+        subplot(211); plot(G1_pad);
+    end
+    subplot(212); plot(real(G1));    
+end
+
+
+
+
+function w=shiftWin(w)
+%---------------------------------------------------------------------
+% shift window to centre
+%---------------------------------------------------------------------
+w=circshift(w(:),ceil(length(w)/2));