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

paradigma/ppg/hr_functions/TFD toolbox JOT/decimated_TFDs/dec_di_gdtfd.m

@@ -0,0 +1,194 @@
+%-------------------------------------------------------------------------------
+% dec_di_gdtfd: decimated Doppler-independent kernel TFD ρ[nᵢ,bk], where b is an
+% integer value and nᵢ is the set nᵢ ={ nᵢ | 1≤i≤U }, with 0≤nᵢ≤N-1
+%
+% Syntax: tfd=dec_di_gdtfd(x,lag_win_params,time_dec,freq_dec,Nfreq)
+%
+% Inputs: 
+%      x = input signal (either real-valued signal of length-N or
+%          complex-valued analytic signal of length-2N)
+%
+%      lag_win_params = lag window parameters in cell form:
+%                 {win_length,win_type,win_param,lag_or_not} where
+%                     - win_length is the sample length of the window
+%                     - win_type is the type of window 
+%                     - [optional] win_param is the parameter of the window 
+%                     - [optional] lag_or_not is either 0 (define window in the lag
+%                     domain, which is the default) or 0 (define window the frequency domain)
+%                 e.g. {121, 'hamm'}; {121, 'tukey', 0.2}; {127,'cosh',0.01,0}
+%
+%      time_dec = decimation factor a in the time domain; a/Ntime is integer
+%      freq_dec = decimation factor b in the frequency domain; b/Nfreq is integer
+%
+%      Nfreq = frequency oversampling value; must be greater than length of lag window
+%
+% See also: DI_GDTFD, GET_ANALYTIC_SIGNAL, GEN_LAG_KERN, FFT
+%
+% Outputs: 
+%     tfd = U x (b/Nfreq) time–frequency distribution
+%
+% Example:
+%     N=1024; Nfreq=128; ni=[100:4:900]; b=2;
+%     x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
+%     
+%     c=dec_di_gdtfd(x,{101,'hann'},ni,b,Nfreq);
+%     vtfd(c,x,1,ni);
+
+
+% John M. O' Toole, University College Cork
+% Started: 23-04-2014
+%
+% last update: Time-stamp: <2014-07-23 16:22:59 (otoolej)>
+%-------------------------------------------------------------------------------
+function tfd=dec_di_gdtfd(x,lag_win_params,time_dec,freq_dec,Nfreq)
+if(nargin<2 || isempty(lag_win_params)), lag_win_params={101,'hamm'}; end
+if(nargin<3 || isempty(time_dec)), time_dec=[]; end
+if(nargin<4 || isempty(freq_dec)), freq_dec=1; end
+if(nargin<5 || isempty(Nfreq)), Nfreq=[]; end
+
+DBplot=0;
+DBmem=0;
+DBtest=0;
+DBtime=0;
+DBverbose=0;
+
+
+if(DBtime), time_start=tic; end
+%---------------------------------------------------------------------
+% 1. convert real-valued signal to analytic signal of length 2N
+%---------------------------------------------------------------------
+[z,N2,N,Nh]=get_analytic_signal(x);
+
+
+%---------------------------------------------------------------------
+% 2. generate time--lag signal function (for positive-lag values only)
+%---------------------------------------------------------------------
+[g2,P,Ph_floor,Nfreq]=gen_lag_kern(lag_win_params,N,Nfreq);
+Nh=ceil(Nfreq/2);
+Ph=ceil(P/2);
+
+
+% check decimation parameters and return as sequence:
+if(length(freq_dec)>1)
+    error('Frequency decimation parameter should be scalar');
+end
+[n_seq,U]=check_dec_params_seq(time_dec,N,'time',0);
+[k_seq,J,freq_dec]=check_dec_params_seq(freq_dec,Nfreq,'frequency',1);
+Jh=ceil(J/2);  J_extend=2*Jh+2;
+
+
+if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+tfd=zeros(U,J_extend); 
+if(J~=Nfreq)
+    m_real=1:Jh+1; m_imag=(J_extend-Jh):(J_extend);
+else
+    m_real=1:Ph; m_imag=(J-Ph+1):J;
+end
+
+
+
+m=0:(Ph-1); mb=1:(Ph-1);
+for in=1:U
+    n=n_seq(in);
+    inp=mod(n+m,N2);  inn=mod(n-m,N2); 
+    
+    if(J~=Nfreq)
+        % need to fold signal function (for decimation in frequency-direction):        
+        K_time_slice=zeros(1,Nfreq);
+        K_time_slice(m+1)=g2(m+1).*z(inp+1).*conj( z(inn+1) );
+        K_time_slice(Nfreq-mb+1)=conj(K_time_slice(mb+1));
+
+        R_fold=fold_vector_half(K_time_slice,J,Jh,freq_dec);
+    else
+        % or if not then do as usual:
+        K_time_slice(m+1)=g2(m+1).*z(inp+1).*conj( z(inn+1) );
+
+        R_fold=K_time_slice;
+    end
+    
+    tfd(in,m_real)=real( R_fold );
+    tfd(in,m_imag)=imag( R_fold );    
+end
+
+if(DBmem), s=whos; fprintf('K: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+
+%-------------------------------------------------------------------------
+% 3.  Expand R for positive and negative lag values and DFT back to 
+%     time--frequency domain
+%-------------------------------------------------------------------------
+if(J~=Nfreq)
+    m=0:Jh; mb=1:(Jh-1);
+else
+    m=0:(Ph-1); mb=1:(Ph-1);
+end
+    
+
+for n=0:2:(U-2)
+    R_even_half=complex(tfd(n+1,m_real),tfd(n+1,m_imag));
+    R_odd_half =complex(tfd(n+2,m_real),tfd(n+2,m_imag));    
+    
+    R_tslice_even=zeros(1,J);  R_tslice_odd=zeros(1,J);
+    R_tslice_even(m+1)=R_even_half(m+1);
+    R_tslice_odd(m+1) =R_odd_half(m+1);
+    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
+    R_tslice_odd(J-mb+1) =conj( R_odd_half(mb+1) );
+    
+    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
+
+    tfd(n+1,1:J)=real(tfd_time_slice);
+    tfd(n+2,1:J)=imag(tfd_time_slice);
+end
+
+% one extra FFT if U is odd:
+if(rem(U,2))
+    R_even_half=complex(tfd(U,m_real),tfd(U,m_imag));
+    R_tslice_even=zeros(1,J);
+    R_tslice_even(m+1)=R_even_half(m+1);
+    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
+    tfd_time_slice=fft( R_tslice_even );
+
+    tfd(U,1:J)=real(tfd_time_slice);
+end
+tfd=tfd(:,1:J);
+
+if(DBmem), s=whos; fprintf('end: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+scale_factor=1/Nfreq;
+tfd=tfd.*scale_factor;
+
+if(DBtime), dispVars( toc(time_start) ); end
+
+
+%---------------------------------------------------------------------
+% END; testing and plotting
+%---------------------------------------------------------------------
+if(DBtest)
+    if(DBtime),  time_start=tic; end
+    tfd_test=full_gdtfd_testing_version(x,'pwvd',{P,lag_win_params{2:end}});
+    if(DBtime),  dispVars( toc(time_start) ); end
+
+    if(Nfreq==N)
+        dispEE(tfd_test(n_seq+1,k_seq+1),tfd);        
+    else
+        b=N/Nfreq; 
+        if( b==floor(b) )
+            dispEE(tfd_test(n_seq+1,(b.*k_seq)+1),tfd./b);
+        end
+    end
+
+end
+if(DBverbose)
+    fprintf('size=%dx%d; max=%g; total energ:%d\n', size(tfd,1), size(tfd,2), max(tfd(:)), ...
+            sum(tfd(:)));
+end
+if(DBplot)
+    figure(1); clf; 
+    vtfd(tfd,real(x(1:N)));
+    
+    figure(9); clf; hold all;
+    subplot(211); hold all; plot(sum(tfd')'); plot( abs(z(1:N)).^2 );
+    subplot(212); hold all; plot(sum(tfd')' - abs(z(n_seq+1)).^2 );    
+end
+
+

paradigma/ppg/hr_functions/TFD toolbox JOT/decimated_TFDs/dec_li_gdtfd.m

@@ -0,0 +1,200 @@
+%-------------------------------------------------------------------------------
+% dec_li_gdtfd: decimated lag-independent kernel TFD ρ[an,kᵢ], where a is an integer
+% value and kᵢ is the set kᵢ ={ kᵢ | 1≤i≤V }, with 0≤kᵢ≤N-1
+%
+% Syntax: tfd=dec_li_gdtfd(x,dopp_win_params,time_dec,freq_dec,Ntime)
+%
+% Inputs: 
+%      x = input signal (either real-valued signal of length-N or
+%          complex-valued analytic signal of length-2N)
+%
+%      dopp_win_params = Doppler window parameters in cell form:
+%                 {win_length,win_type,win_param,Doppler_or_not} where
+%                     - win_length is the sample length of the window
+%                     - win_type is the type of window 
+%                     - [optional] win_param is the parameter of the window 
+%                     - [optional] Doppler_or_not is either 1 (define window in the Doppler
+%                     domain, which is the default) or 0 (define window in the time domain)
+%                 e.g. {121, 'hamm'}; {121, 'tukey', 0.2}; {127,'cosh',0.01,0}
+%
+%      time_dec  = decimation factor a in the time domain; a/Ntime is integer
+%      freq_dec  = decimation factor b in the frequency domain; b/Nfreq is integer
+%
+%      Ntime = time oversampling value; must be greater than length of Doppler window
+%
+% Outputs: 
+%     tfd = (a/Ntime) x V time–frequency distribution
+%
+% See also: LI_GDTFD, GET_ANALYTIC_SIGNAL, GEN_DOPPLER_KERN, FFT
+%
+% Example:
+%     N=1024; Ntime=64; a=2; ki=[150:4:850]; 
+%     x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
+%
+%     c=dec_li_gdtfd(x,{51,'hann'},a,ki,Ntime); 
+%     vtfd(c,x,1,[],ki./(N*2));
+
+% John M. O' Toole, University College Cork
+% Started: 23-04-2014
+%
+% last update: Time-stamp: <2014-07-23 16:19:59 (otoolej)>
+%-------------------------------------------------------------------------------
+function tfd=dec_li_gdtfd(x,dopp_win_params,time_dec,freq_dec,Ntime)
+if(nargin<2 || isempty(dopp_win_params)), dopp_win_params={51,'hann'}; end
+if(nargin<3 || isempty(time_dec)), time_dec=1; end
+if(nargin<4 || isempty(freq_dec)), freq_dec=1; end
+if(nargin<5 || isempty(Ntime)), Ntime=[]; end
+
+
+DBplot=0;
+DBmem=0;
+DBtest=0;
+DBtime=0;
+DBverbose=0;
+
+
+if(DBtime), time_start=tic; end
+%---------------------------------------------------------------------
+% 1. convert real-valued signal to analytic signal of length 2N
+%---------------------------------------------------------------------
+[z,N2,N,Nh]=get_analytic_signal(x);
+
+
+%---------------------------------------------------------------------
+% 2. generate time--lag signal function (for positive-lag values only)
+%---------------------------------------------------------------------
+[G1,Q,Ntime]=gen_Doppler_kern(dopp_win_params,N,Ntime);
+Qh=ceil(Q/2);
+
+
+% check decimation parameters and return as sequence:
+if(length(time_dec)>1)
+    error('Frequency decimation parameter should be scalar');
+end
+[n_seq,L,time_dec]=check_dec_params_seq(time_dec,Ntime,'time',1);
+[k_seq,V]=check_dec_params_seq(freq_dec,N,'frequency',0);
+Lh=ceil(L/2);  L_extend=2*Lh+2;
+
+
+if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+tfd=zeros(L_extend,V); 
+if(L~=Ntime)
+    l_real=1:(Lh+1); l_imag=(L_extend-Lh):L_extend;
+else
+    l_real=1:Qh; l_imag=(L-Qh+1):L;
+end
+
+
+Z=fft(z);
+l=0:(Qh-1); lb=1:(Qh-1);
+for ik=1:V
+    k=k_seq(ik);
+    inp=mod(k+l,N2);  inn=mod(k-l,N2); 
+    inpN=mod(k+l+N,N2);  innN=mod(k-l-N,N2);     
+    
+    if(L~=Ntime)
+        K_doppler_slice=zeros(1,Ntime);
+        K_doppler_slice(l+1)=G1(l+1).*( Z(inp+1).*conj( Z(inn+1) )  + ...
+                                        Z(inpN+1).*conj( Z(innN+1) ) );
+        K_doppler_slice(Ntime-lb+1)=conj( K_doppler_slice(lb+1) );
+        
+        R_fold=fold_vector_half(K_doppler_slice./2,L,Lh,time_dec);
+    else
+        
+        K_doppler_slice=G1(l+1).*( Z(inp+1).*conj( Z(inn+1) )  + ...
+                                   Z(inpN+1).*conj( Z(innN+1) ) );
+        
+        R_fold=K_doppler_slice;
+    end
+    
+    tfd(l_real,ik)=real( R_fold );
+    tfd(l_imag,ik)=imag( R_fold );    
+end
+
+
+if(DBmem), s=whos; fprintf('K: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+
+
+%-------------------------------------------------------------------------
+% 3.  Expand R for positive and negative lag values and DFT back to 
+%     time--frequency domain
+%-------------------------------------------------------------------------
+if(L~=Ntime)
+    l=0:Lh; lb=1:(Lh-1);
+else
+    l=0:(Qh-1); lb=1:(Qh-1);
+end
+
+for k=0:2:(V-2)
+    R_even_half=complex(tfd(l_real,k+1),tfd(l_imag,k+1));
+    R_odd_half =complex(tfd(l_real,k+2),tfd(l_imag,k+2));    
+    
+    R_tslice_even=zeros(L,1);  R_tslice_odd=zeros(L,1);
+    R_tslice_even(l+1)=R_even_half(l+1);
+    R_tslice_odd(l+1) =R_odd_half(l+1);
+    R_tslice_even(L-lb+1)=conj( R_even_half(lb+1) );
+    R_tslice_odd(L-lb+1) =conj( R_odd_half(lb+1) );
+    
+    tfd_freq_slice=ifft( R_tslice_even+j.*R_tslice_odd );
+
+    tfd(1:L,k+1)=real(tfd_freq_slice);
+    tfd(1:L,k+2)=imag(tfd_freq_slice);
+end
+
+% one extra FFT if V is odd
+if(rem(V,2))
+    R_even_half=complex(tfd(l_real,V),tfd(l_imag,V));
+    
+    R_tslice_even=zeros(L,1);  
+    R_tslice_even(l+1)=R_even_half(l+1);
+    R_tslice_even(L-lb+1)=conj( R_even_half(lb+1) );
+    
+    tfd_freq_slice=ifft( R_tslice_even );
+
+    tfd(1:L,V)=real(tfd_freq_slice);
+end
+tfd=tfd(1:L,:);
+
+if(DBmem), s=whos; fprintf('tfd (end): mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+
+if(time_dec==1)
+    scale_factor=1/(2*N);
+else
+    scale_factor=1/(N*time_dec);
+end
+tfd=tfd.*scale_factor;
+
+if(DBtime), dispVars( ['time: ' num2str(toc(time_start))] ); end
+
+
+%---------------------------------------------------------------------
+% END; testing and plotting
+%---------------------------------------------------------------------
+if(DBtest)
+    if(DBtime), time_start=tic; end
+    tfd_test=full_gdtfd_testing_version(x,'swvd',{Q,dopp_win_params{2:end}});
+    if(DBtime), dispVars( ['testing time: ' num2str(toc(time_start))] ); end
+    if(Ntime==N)
+        dispEE(tfd_test(n_seq+1,k_seq+1),tfd);
+    else
+        a=N/Ntime; 
+        if( a==floor(a) )
+            dispEE(tfd_test((a.*n_seq)+1,k_seq+1),tfd./a);
+        end
+    end
+end
+if(DBverbose)
+    fprintf('size=%dx%d; max=%g; total energ:%d\n', size(tfd,1), size(tfd,2), max(tfd(:)), ...
+            sum(tfd(:)));
+end
+if(DBplot)
+    figure(1); clf; 
+    vtfd(tfd,real(x(1:N)));
+    
+    figure(9); clf; hold all;
+    Z=fft(z);
+    subplot(211); hold all; plot(sum(tfd)); plot( abs(Z(1:N)).^2./(2*N) );
+    subplot(212); hold all; plot(sum(tfd)' - abs(Z(k_seq+1)).^2./(2*N) );    
+end

paradigma/ppg/hr_functions/TFD toolbox JOT/decimated_TFDs/dec_nonsep_gdtfd.m

@@ -0,0 +1,229 @@
+%-------------------------------------------------------------------------------
+% dec_nonsep_gdtfd: decimated TFD with non-separable kernel ρ[an,bk], where a,b are
+% integer values
+% 
+%
+% Syntax: tfd=dec_nonsep_gdtfd(x,kern_type,kern_params,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 = { 'wvd' | 'swvd' | 'pwvd' | 'sep' | 'cw' | 'mb' }
+%            wvd  - Wigner-Ville distribution
+%            swvd - Smoothed Wigner-Ville distribution
+%                   (lag-independent kernel)
+%            pwvd - Pseudo Wigner-Ville distribution
+%                   (Doppler-independent kernel)
+%            sep  - Separable-kernel distribution 
+%                   (combintation of SWVD and PWVD)
+%            mb   - Modified-B distribution
+%            cw   - Choi-Williams distribution
+% 
+%      kern_params = cell of kernel parameters:
+%            wvd  - {}
+%            swvd - {win_length,win_type,[win_param]}
+%                   e.g. {11,'hamm'}
+%            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} }
+%            mb   - {beta_parameter} in the range 1<beta<0
+%            cw   - {sigma_parameter}
+%
+%     time_dec  = decimation factor a in the time domain; a/N is integer
+%     freq_dec  = decimation factor b in the frequency domain; b/N is integer
+%
+% Outputs: 
+%     tfd = a/N x b/N time–frequency distribution
+%
+% See also: NONSEP_GDTFD, GET_ANALYTIC_SIGNAL, GEN_DOPPLER_LAG_KERN, FFT
+%
+% Example:
+%      N=1024; a=2; b=8;
+%      x=gen_LFM(N,0.1,0.3)+gen_LFM(N,0.4,0.1);
+%      c=dec_nonsep_gdtfd(x,'cw',{100},a,b); 
+%      vtfd(c,x);
+
+% John M. O' Toole, University College Cork
+% Started: 23-04-2014
+%
+% last update: Time-stamp: <2014-09-15 13:19:16 (otoolej)>
+%-------------------------------------------------------------------------------
+function tfd=dec_nonsep_gdtfd(x,kern_type,kern_params,time_dec,freq_dec)
+if(nargin<2 || isempty(kern_type)),   kern_type='cw'; end
+if(nargin<3 || isempty(kern_params)), kern_params=10; end
+if(nargin<4 || isempty(time_dec)),    time_dec=1; end
+if(nargin<5 || isempty(freq_dec)),    freq_dec=1; end
+
+
+DBplot=0;
+DBmem=0;
+DBtest=0;
+DBtime=0;
+DBverbose=0;
+
+
+if(DBtime), time_start=tic; end
+%---------------------------------------------------------------------
+% 1. convert real-valued signal to analytic signal of length 2N
+%---------------------------------------------------------------------
+[z,N2,N,Nh]=get_analytic_signal(x);
+
+% if product-kernel then generate window now:
+G1=get_prod_kernel(kern_type,kern_params,N);
+
+
+%---------------------------------------------------------------------
+% 2. check decimation parameters 
+%---------------------------------------------------------------------
+if(length(time_dec)>1 || length(freq_dec)>1)
+    error('Frequency and time decimation parameters should be scalar');
+end
+[n_seq,L,time_dec]=check_dec_params_seq(time_dec,N,'time',1);
+[k_seq,J,freq_dec]=check_dec_params_seq(freq_dec,N,'frequency',1);
+Jh=ceil(J/2);  J_extend=2*Jh+2;
+
+if(DBmem), s=whos; fprintf('start: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+tfd=zeros(L,J_extend); 
+m_real=1:Jh+1; m_imag=(J_extend-Jh):(J_extend);
+
+if(DBmem), s=whos; fprintf('declare TFD: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+
+%---------------------------------------------------------------------
+% 3. generate time--lag signal function (for positive-lag values only)
+%---------------------------------------------------------------------
+n=0:N-1; mb=1:Jh-1;
+for m=0:Jh
+
+    %------------------------------------
+    % Fold in the lag direction
+    %------------------------------------
+    af_lag_slice=zeros(N,1);    
+    for p=0:freq_dec-1
+        mmod=(p*J+m);
+        g_lag_slice=gen_Doppler_lag_kern(kern_type,kern_params,N,mmod+1);
+        
+        if(mmod<=Nh)
+            inp=mod(n+mmod,N2); inn=mod(n-mmod,N2);
+            K_lag_slice=z(inp+1).*conj(z(inn+1));
+        else
+            inp=mod(n+N-mmod,N2); inn=mod(n-N+mmod,N2);
+            K_lag_slice=conj(z(inp+1)).*z(inn+1);            
+        end
+        
+        af_lag_slice=af_lag_slice + fft(K_lag_slice).*g_lag_slice;
+    end
+
+    %------------------------------------
+    % Fold in the Doppler direction
+    %------------------------------------
+    af_lag_fold=fold_vector_full(af_lag_slice,L,time_dec);
+    
+    %------------------------------------
+    % DFT the lag slice to the time--lag 
+    % domain.
+    %------------------------------------
+    R_lag_slice=ifft(af_lag_fold);
+    tfd(:,m_real(m+1))=real(R_lag_slice);
+    tfd(:,m_imag(m+1))=imag(R_lag_slice);    
+end
+
+
+if(DBmem), s=whos; fprintf('R: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+%-------------------------------------------------------------------------
+% 4.  Expand R for positive and negative lag values and DFT back to 
+%     time--frequency domain
+%-------------------------------------------------------------------------
+m=0:Jh; mb=1:(Jh-1);
+for n=0:2:(L-2)
+    R_even_half=complex(tfd(n+1,m_real),tfd(n+1,m_imag));
+    R_odd_half =complex(tfd(n+2,m_real),tfd(n+2,m_imag));
+    
+    R_tslice_even=zeros(J,1);  R_tslice_odd=zeros(J,1);
+    R_tslice_even(m+1)=R_even_half(m+1);
+    R_tslice_odd(m+1) =R_odd_half(m+1);
+    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
+    R_tslice_odd(J-mb+1) =conj( R_odd_half(mb+1) );
+    
+    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
+
+    tfd(n+1,1:J)=real(tfd_time_slice);
+    tfd(n+2,1:J)=imag(tfd_time_slice);
+end
+
+
+% one extra FFT if L is odd:
+if(rem(L,2))
+    R_even_half=complex(tfd(L,m_real),tfd(L,m_imag));
+    
+    R_tslice_even=zeros(J,1);  
+    R_tslice_even(m+1)=R_even_half(m+1);
+    R_tslice_even(J-mb+1)=conj( R_even_half(mb+1) );
+    
+    tfd_time_slice=fft( R_tslice_even+j.*R_tslice_odd );
+
+    tfd(L,1:J)=real(tfd_time_slice);
+end
+
+tfd=tfd(:,1:J);
+
+if(DBmem), s=whos; fprintf('end: mem=%s\n',disp_bytes(sum([s.bytes]))); end
+
+scale_factor=1/N;
+tfd=tfd.*scale_factor;
+
+if(DBtime), dispVars( toc(time_start) ); end
+
+
+%---------------------------------------------------------------------
+% END; testing and plotting
+%---------------------------------------------------------------------
+if(DBtest)
+    if(DBtime),  time_start=tic; end
+    tfd_test=full_gdtfd_testing_version(x,kern_type,kern_params);
+    if(DBtime),  dispVars( toc(time_start) ); end
+
+    dispEE(tfd_test(n_seq+1,k_seq+1),tfd);
+end
+if(DBverbose)
+    fprintf('size=%dx%d; max=%g; total energ:%d\n', size(tfd,1), size(tfd,2), max(tfd(:)), ...
+            sum(tfd(:)));
+end
+if(DBplot)
+    figure(1); clf; 
+    vtfd(tfd,real(x(1:N)));
+    
+    figure(9); clf; hold all;
+    subplot(211); hold all; plot(sum(tfd')'); plot( abs(z(1:N)).^2 );
+    subplot(212); hold all; plot(sum(tfd')' - abs(z(n_seq+1)).^2 );    
+    
+    figure(10); clf; hold all;
+    Z=fft(z);
+    subplot(211); hold all; plot(sum(tfd)); plot( abs(Z(1:N)).^2./(2*N) );
+    subplot(212); hold all; plot(sum(tfd)' - abs(Z(k_seq+1)).^2./(2*N) );    
+end
+
+
+
+function G1=get_prod_kernel(tfd_type,tfd_params,N)
+%---------------------------------------------------------------------
+% Generate window for product-kernel
+%---------------------------------------------------------------------
+
+if( strcmp(tfd_type,'RID')==1 || strcmp(tfd_type,'prod')==1 || ...
+    strcmp(tfd_type,'product')==1 )
+    
+% $$$     % oversample the window:
+% $$$     L_dopp=N*N2;
+    
+    G1=gen_Doppler_kern(tfd_params,N);
+    G1=real(G1);
+else
+    G1=[];
+end