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

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

@@ -0,0 +1,314 @@
+%-------------------------------------------------------------------------------
+% gen_Doppler_lag_kern: Doppler--lag kernel (for GDTFD definition)
+%
+% Syntax: kern=gen_Doppler_lag_kern(kern_type,kern_params,N)
+%
+% Input: 
+%   kern_type = { 'wvd' | 'swvd' | 'pwvd' | 'sep' | 'cw' | 'mb'}
+%            wvd  - kernel for Wigner-Ville distribution
+%            swvd - kernel for smoothed Wigner-Ville distribution
+%                   (lag-independent kernel)
+%            pwvd - kernel for pseudo Wigner-Ville distribution
+%                   (Doppler-independent kernel)
+%            sep  - kernel for separable kernel (combintation of SWVD and PWVD)
+%            cw   - kernel for Choi-Williams distribution
+%            mb   - kernel for Modified-B distribution
+% 
+%   kern_params = cell of kernel parameters:
+%            wvd  - {}
+%            swvd - {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
+%            pwvd - {win_length,win_type,[win_param]}
+%                   e.g. {200,'cosh',0.1}
+%            sep  - { {win1_length,win1_type,[win1_param]}, 
+%                    {win2_length,win2_type,[win2_param]}
+%                   where win1 is the Doppler window and win2 is the lag window.
+%                   e.g. { {11,'hamm'}, {200,'cosh',0.1} }
+%            cw   - {sigma_parameter}
+%            mb   - {beta_parameter} in the range 1<beta<0
+%
+%   N = signal length.
+%
+% Output:
+%   g = Doppler--lag smoothing kernel
+%
+% See also: GEN_LAG_KERN, GEN_DOPPLER_KERN, GET_WINDOW, PADWIN
+%
+% Example:
+%      N=128; 
+%      g=gen_Doppler_lag_kern( 'sep',{{N-1,'cosh',0.1,1},{51,'hamm'}},N); 
+%      clf; mesh( fftshift(g) );
+%      xlabel('lag'); ylabel('Doppler');
+%      title('Separable kernel');
+%
+
+% John M. O' Toole, University College Cork
+% Started: 14-04-2014
+%
+% last update: Time-stamp: <2018-01-21 04:51:27 (otoolej)>
+%-------------------------------------------------------------------------------
+function g=gen_Doppler_lag_kern(kern_type,kern_params,N,lag_index,G1)
+if(nargin<3), error('need 3 input arguments'); end
+if(nargin<4 || isempty(lag_index)), lag_index=[]; end
+if(nargin<5 || isempty(G1)), G1=[]; end
+
+
+
+DBplot=0;
+
+lag_sample=2;
+doppler_sample=1/N;
+
+if(isempty(lag_index))
+    lag_index=1:N;
+    g=zeros(N);
+else
+    g=zeros(N,1:length(lag_index));    
+end
+
+
+
+if(~iscell(kern_params))
+    tmp_params{1}=kern_params; 
+    kern_params=tmp_params;
+end
+
+g=get_kern(g,lag_index,kern_type,kern_params,doppler_sample,lag_sample,N,G1);
+
+
+% All kernels are real valued. 
+g=real(g);
+
+if(DBplot)
+    figure(1); clf; 
+    if(length(lag_index)==1)
+        plot( g );
+    else
+        mesh( fftshift(g) );
+    end
+    xlabel('lag'); ylabel('Doppler');
+    title('Separable kernel');
+end
+
+
+
+
+function g=get_kern(g,lag_index,kernel_type,kernel_params,doppler_sample_rate, ...
+                      lag_sample_rate,N,G1)
+%---------------------------------------------------------------------
+% generate the kernels for a given sample rate
+%---------------------------------------------------------------------
+if(nargin<8 || isempty(G1)), G1=[]; end
+
+[Nd,Nl]=size(g);
+l=length(kernel_params);
+
+
+switch kernel_type
+  
+ case {'wvd'}
+  g(:,:)=1;
+
+  
+  %---------------------------------------------------------------------
+  % Smoothed Wigner-Ville (Lag Independent (LI) kernel)
+  % g(l/NT,mT) = W(l/NT)
+  %---------------------------------------------------------------------
+ case 'swvd'
+  
+  if( l<2 ) 
+    error('Need at least two window parameters for SWVD'); 
+  end
+  win_length=kernel_params{1};
+  win_type=kernel_params{2}; 
+  win_param=0; win_param2=1;
+  if( l>=3 ) win_param=kernel_params{3}; end
+  if( l>=4 ) win_param2=kernel_params{4}; end
+  
+
+  G1=get_window(win_length,win_type,win_param);
+  G1=padWin(G1,Nd);
+  
+  
+  % Define window in the time-domain (this is the usual practice):
+  % But could also define in the doppler-domain.
+  if( win_param2==0 )
+    G1=fft(G1);
+    G1=G1./G1(1);
+  end
+  
+  if( isreal_fn(ifft(G1))==0 )
+    warning('Window function g1(t) is NOT real valued.');
+  end
+  
+  for m=1:Nl
+      g(:,m) = G1;
+  end
+  
+  
+  %---------------------------------------------------------------------
+  % Pseudo-Wigner-Ville (Doppler Independent (DI) kernel)
+  % g(l/NT,mT) = g2(mT)
+  %---------------------------------------------------------------------
+ case 'pwvd'
+  
+  if( l<2 ) 
+    error('Need at least two window parameters for PWVD'); 
+  end
+  P=kernel_params{1};
+  win_type=kernel_params{2}; 
+  win_param=0;   win_param2=0;
+  if( l>2 ) win_param=kernel_params{3}; end
+  if( l>3 ) win_param2=kernel_params{4}; end  
+
+  g2=get_window(P,win_type,win_param,win_param2);
+
+  g2=padWin(g2(:),N);
+  g2=g2(lag_index);
+    
+  if( Nd==Nl && isreal_fn(fft(g2))==0 )
+    warning('Window function G2(f) is NOT real valued.');
+  end
+
+  for l=0:Nd-1
+      g(l+1,:)=g2;
+  end
+
+  %---------------------------------------------------------------------
+  % Seperable Kernel
+  %
+  % g(l/NT,mT) = G1(l/NT)g2(mT) 
+  %  
+  %---------------------------------------------------------------------
+ case { 'sep', 'sep-full' }
+
+  if(l<2)
+    error('Need at least two windows parameters.'); 
+  end
+    
+  g1=get_kern(g,lag_index,'swvd',kernel_params{1},doppler_sample_rate,lag_sample_rate,N);
+  g2=get_kern(g,lag_index,'pwvd',kernel_params{2},doppler_sample_rate,lag_sample_rate,N);
+  g=g1.*g2;
+  
+  
+  %---------------------------------------------------------------------
+  % Choi-Williams
+  %
+  % g(l/NT,mT) = exp( -(2 pi m l/N)^2/ sigma ) 
+  %
+  %---------------------------------------------------------------------
+ case {'cw', 'choi-williams', 'choi-will'}
+  
+  if(l>=1) 
+    sigma=kernel_params{1};
+  else
+    sigma=11;
+  end
+  Ndh=ceil(Nd/2);
+  Nlh=ceil(Nl/2);
+  
+
+  % if just at one-lag index:
+  if(length(lag_index)==1)
+    g(1)=1;
+    m=lag_index-1;
+    if(m==(N-1))
+        g(:)=0;
+    elseif(m==0)
+        g(:)=1;
+    else
+        if(m>ceil(N/2)) m=N-m; end
+
+        const = ((2*pi)^2)/sigma;
+        u=1:Ndh-1;
+        u1=u.*doppler_sample_rate; m1=m*lag_sample_rate;
+   
+        g(u+1) = exp( -const.*(u1.*m1).^2 ).';
+        g(Nd-u+1)=g(u+1); 
+    end
+
+    % or for the whole thing: 
+  else
+      g(1,1:Nl)=1; g(1:Nd,1)=1;  
+      
+      const = ((2*pi)^2)/sigma;
+      u=1:Ndh-1;
+      for m=1:Nlh-1
+          
+          u1=u.*doppler_sample_rate; m1=m*lag_sample_rate;
+          g(u+1,m+1)=exp( -const.*(u1.*m1).^2 ).';
+          
+          g(Nd-u+1,m+1)=g(u+1,m+1); 
+          g(u+1,Nl-m+1)=g(u+1,m+1); 
+          g(Nd-u+1,Nl-m+1)=g(u+1,m+1); 
+      end
+  end
+  
+  %---------------------------------------------------------------------
+  % Product kernel (sometimes called a RID kernel)
+  %
+  % g(l/NT,2mT)=H(l2m/N)
+  %---------------------------------------------------------------------
+  case { 'prod', 'RID', 'product' }
+
+    % NOT WORKING:
+% $$$     if(length(lag_index)==1)
+% $$$         m=lag_index;
+% $$$         
+% $$$         g(1)=1;
+% $$$         if(m==N)
+% $$$             g(:)=0;
+% $$$         else
+% $$$             if(m>ceil(N/2)) m=N-m; end
+% $$$             
+% $$$             u=1:floor(Nd/2);
+% $$$             im=mod(u*m,length(G1));
+% $$$             
+% $$$             g(u+1)=G1(im+1);
+% $$$             g(Nd-u+1)=g(u+1); 
+% $$$         end
+% $$$     else
+% $$$         keyboard;
+% $$$         if(isempty(G1))
+% $$$             [d,d2,d3,G1]=gen_Doppler_kern(kernel_params,N,N);
+% $$$         end
+% $$$         Ndh=ceil(Nd/2);  Nlh=ceil(Nl/2);
+% $$$         g=zeros(Nd,Nl);
+% $$$ 
+% $$$         g(1,1:Nl)=G1(1); g(1:Nd,1)=G1(1);  
+% $$$ 
+% $$$         u=1:Ndh-1;
+% $$$         for m=1:Nlh-1
+% $$$             g(u+1,m+1)=G1( mod(u.*m,N)+1 );
+% $$$             
+% $$$ % $$$             g(Nd-u+1,m+1)=g(u+1,m+1); 
+% $$$ % $$$             g(u+1,Nl-m+1)=g(u+1,m+1); 
+% $$$ % $$$             g(Nd-u+1,Nl-m+1)=g(u+1,m+1); 
+% $$$         end
+% $$$         
+% $$$     end
+    
+   
+  %---------------------------------------------------------------------
+  % Modified-B (a specific SWVD or LAG INDEPENDENT kernel)
+  %
+  % G(nT,mT) = cosh^{-2*beta}(n)   (defined in time--lag domain)
+  %---------------------------------------------------------------------
+ case { 'mb', 'modified-b' }
+
+  G1=get_kern(g,lag_index,'swvd',{N-1,'cosh',kernel_params{1}}, ...
+                doppler_sample_rate,lag_sample_rate,N);   
+
+  for m=1:Nl
+      g(:,m) = G1;
+  end
+
+  
+ otherwise
+  error(['Unknown kernel type: ' kernel_type]);
+  
+end
+

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

@@ -0,0 +1,123 @@
+%-------------------------------------------------------------------------------
+% gen_lag_kern: smoothing window for Lag-kernel g2[m]; provides some checking of 
+%               the parameters
+%
+% Syntax: [g2,P,Ph_floor,Nfreq]=gen_lag_kern(win_params,N,Nfreq)
+%
+%
+%  Input:
+%       win_params - cell of {win_length,win_type,[win_param],[lag_or_freq]}
+%                     e.g. {11,'hamm',0,1}
+%                     the parameter lag_or_freq is either:
+%                       0 = to define window in the lag-domain
+%                       1 = to define window in the frequency-domain
+%       N          - lenght of signal
+%       Nfreq      - number of sample points in the frequency direction
+%
+%  Output:
+%       g2       - lag kernel g_2(2mT)
+%       P        - length of g2 (as may have changed)
+%       Ph_floor - floor(P/2)
+%       Nfreq    - Nfreq (as may have changed)
+%
+%  See also: GEN_DOPPLER_KERN, GEN_DOPPLER_LAG_KERN, GET_WINDOW, PADWIN
+%
+%  Example:
+%       g2=get_lag_kernel({61,'hann'},128,512);
+%
+
+% John M. O' Toole, University College Cork
+% Started: 16-04-2014
+%
+% last update: Time-stamp: <2021-08-24 17:42:46 (otoolej)>
+%-------------------------------------------------------------------------------
+function [g2,P,Ph_floor,Nfreq]=gen_lag_kern(win_params,N,Nfreq)
+if(nargin<3 || isempty(Nfreq)), Nfreq=[]; end
+
+
+DBplot=0;
+
+
+%---------------------------------------------------------------------
+% 1. make sure parameters are ok
+%---------------------------------------------------------------------
+P=win_params{1};
+% window length can not be greater than N:
+if(P>N)
+    warning('length of g2 too long: chopping down length N');
+    P=N;
+end
+% force window length to be odd-value:
+if(P/2==fix(P/2))
+    P=P-1; 
+    warning(['Forcing P to be odd. P is now P=',num2str(P)]);
+end
+Ph_floor=floor(P/2);
+
+
+l=length(win_params);
+if( l<2 ) 
+  error('Need at least two window parameters'); 
+end
+
+if(isempty(Nfreq)), Nfreq=P+1; end
+
+if(Nfreq<(P+1))
+    warning('Nfreq is too short: increasing length to (P+1)');
+    Nfreq=P+1;
+end
+
+if(rem(Nfreq,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=0; end
+
+
+g2=get_window(P,win_type,win_extra_param,win_dft_param);
+g2=g2(:);
+
+g2_pad=padWin(g2,Nfreq);
+
+
+%---------------------------------------------------------------------
+% 3. [OPTIONAL] post-process window
+%---------------------------------------------------------------------
+% a. if normalizing window:
+if(length(win_params)>4)
+  if(strcmpi(win_params{5},'y')==1)
+    g2=g2./sum(g2);
+  end
+end
+
+% b. if (time) reversing window
+if(length(win_params)>5 )
+  g2=shiftWin(g2);
+  g2_pad=shiftWin(g2_pad);
+end
+
+
+if(DBplot)
+    figure(20); clf; hold all;
+    subplot(211); plot(g2_pad);
+    subplot(212); plot(g2);    
+end
+
+
+function w=shiftWin(w)
+%---------------------------------------------------------------------
+% shift window to centre
+%---------------------------------------------------------------------
+w=circshift(w(:),ceil(length(w)/2));
+
+
+
+
+

paradigma/ppg/hr_functions/TFD toolbox JOT/dec_tfd.m

@@ -0,0 +1,154 @@
+%-------------------------------------------------------------------------------
+% dec_tfd: Generate decimated (or sub-sampled) time-frequency distributions
+%
+% Syntax: tf=dec_tfd(x,kern_type,kern_params,Ntime,Nfreq,time_dec,freq_dec)
+%
+% Inputs: 
+%      x = input signal (either real-valued signal of length-N or
+%          complex-valued analytic signal of length-2N)
+%
+%      kern_type   = kernel type, either nonseparable, separable, Doppler-independent
+%                    (DI) or lag-independent (LI):   { 'nonsep' | 'sep' | 'DI' | 'LI' }
+%
+%      kern_params = kernel parameters; different depending on kernel type
+%
+%                    if nonseparable kernel, then form: { kern_name, kern_param}
+%                      e.g. tf=full_tfd( x, 'nonsep', { 'cw', 100 } );
+%
+%                    if Doppler-independent kernel, then of the form: 
+%                      { window_length, window_type, [window_parameter (optional)] }
+%                      e.g. tf=full_tfd( x, 'DI', {101,'hann'} );
+%
+%                    if lag-independent kernel, then of the form: 
+%                      { window_length, window_type, [window_parameter (optional)] }
+%                      e.g. tf=full_tfd( x, 'LI', {101,'cosh',0.01} );
+%
+%                    if separable kernel, then of the form: { doppler_window, lag_window }
+%                    where doppler_window is of the form: { window_length, window_type,
+%                    [window_parameter (optional)] }; same format for lag window
+%                      e.g. tf=full_tfd( x, 'sep', { {101, 'cosh', 0.05}, {101,'hann'} } );
+%
+%     Ntime       = over-sampling in the time direction; only applicable for separable
+%                   and lag-independent kernels
+%
+%     Nfreq       = over-sampling in the frequency direction; only applicable for separable
+%                   and Doppler-independent kernels
+%
+%     time_dec  = decimation factor in the time domain; for the Doppler-independent kernel
+%     this value can be either a vector or a scalar; for all other kernel types this
+%     value is an integer scalar a.
+%
+%     freq_dec  = decimation factor in the frequency domain; for the lag-independent kernel
+%     this value can be either a vector or a scalar; for all other kernel types this
+%     value is an integer scalar b.
+%
+% Outputs: 
+%     tf - time-frequency distribution of size (a/N) x (b/N) (non-separable kernel),
+%          or (a/Ntime) x (b/Nfreq) (separable kernel),
+%          or U x (b/Nfreq) (Doppler-independent kernel, U is length of time_dec vector),
+%          or (a/Ntime) x V (lag-independent kernel, V is length of freq_dec vector)
+%
+% See also: DEC_NONSEP_GDTFD, DEC_SEP_GDTFD, DEC_LI_GDTFD, DEC_DI_GDTFD
+%
+% Example:
+%     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));                       
+      
+% John M. O' Toole, University College Cork
+% Started: 23-07-2014
+%
+% last update: Time-stamp: <2019-06-05 17:05:19 (otoolej)>
+%-------------------------------------------------------------------------------
+function tf=dec_tfd(x,kern_type,kern_params,Ntime,Nfreq,time_dec,freq_dec)
+if(nargin<2 || isempty(kern_type)), kern_type='sep'; end
+if(nargin<3 || isempty(kern_params)), kern_params={{51,'hann'},{101,'hann'}}; end
+if(nargin<4 || isempty(time_dec)), time_dec=[]; end
+if(nargin<5 || isempty(freq_dec)), freq_dec=[]; end
+if(nargin<6 || isempty(Ntime)), Ntime=[]; end
+if(nargin<7 || isempty(Nfreq)), Nfreq=[]; end
+
+
+% set to 1 if want to see how much memory is used:
+DBmem=0;
+
+
+kern_type=lower(kern_type);
+switch kern_type
+  case { 'nonsep', 'ns', 'nonseparable', 'non-separable', 'non-sep' }
+    %---------------------------------------------------------------------
+    % 1. Non-separable kernel; Doppler-lag form: g[l,m]
+    %---------------------------------------------------------------------
+    nonsep_params=[];
+    if(~iscell(kern_params))
+        nonsep_name=kern_params;
+    else
+        nonsep_name=kern_params{1};
+        if(length(kern_params)>1)
+            nonsep_params=kern_params{2};
+        end
+    end
+            
+    tf=dec_nonsep_gdtfd(x,nonsep_name,nonsep_params,time_dec,freq_dec);
+
+    
+  case  { 'sep', 'separable' }
+    %---------------------------------------------------------------------
+    % 2. separable kernel; Doppler-lag form: G1[l]g2[m]
+    %---------------------------------------------------------------------
+    if(~iscell(kern_params) | (iscell(kern_params) & length(kern_params)<2) )
+        error(['separable kernel parameters should be of the form: ' ...
+               '{ {dopp_win_length,dopp_win_name}, {lag_win_length,lag_win_name} }']);
+    end
+    
+    tf=dec_sep_gdtfd(x,kern_params{1},kern_params{2},time_dec,freq_dec,Ntime,Nfreq);
+    
+    
+  case { 'di', 'doppler-independent', 'dopp.-indep', 'dopp-indep', 'pwvd', 'p-wvd' }
+    %---------------------------------------------------------------------
+    % 3. Doppler-independent kernel: Doppler-lag form: g2[m]
+    %---------------------------------------------------------------------
+    if(~iscell(kern_params))
+        error(['Doppler-independent kernel parameters should be of the form: ' ...
+               '{win_length,win_name}']);
+    end
+    
+    tf=dec_di_gdtfd(x,kern_params,time_dec,freq_dec,Nfreq);
+
+    
+  case { 'li', 'lag-independent',  'lag-indep', 'swvd', 's-wvd' }
+    %---------------------------------------------------------------------
+    % 4. Lag-independent kernel: Doppler-lag form: G1[l]
+    %---------------------------------------------------------------------
+    if(~iscell(kern_params))
+        error(['lag-independent kernel parameters should be of the form: ' ...
+               '{win_length,win_name}']);
+    end
+
+    tf=dec_li_gdtfd(x,kern_params,time_dec,freq_dec,Ntime);
+    
+  otherwise
+    warning('kern_type should be either: nonsep, sep, DI, or LI');
+    tf=[];
+end
+
+
+if(DBmem), s=whos; fprintf('total memory used: mem=%s\n',disp_bytes(sum([s.bytes]))); end