s2let_transform_synthesis_mw

 s2let_transform_synthesis_mw
 Compute spin directional wavelet transform, output in pixel space.

 Default usage :

   f = s2let_transform_synthesis_mw(f_wav, f_scal, <options>)

 f_wav contains the input wavelet contributions -- MW sampling,
 f_scal contains the input scaling contributions -- MW sampling,
 f is the output field -- MW sampling,

 Option :
  'Reality'         = { false        [do not assume f real (default)],
                        true         [assume f real (improves performance)] }
  'B'               = { Dilation factor; B > 1 (default=2) }
  'L'               = { Harmonic band-limit; L > 1 (default=guessed from input) }
  'N'               = { Azimuthal/directional band-limit; N > 1 (default=L) }
  'Spin'               = { Spin; (default=0) }
  'Upsample'      = { false        [multiresolution algorithm (default)],
                      true       [full resolution wavelets] }
  'Sampling'        = { 'MW'           [McEwen & Wiaux sampling (default)],
                        'MWSS'         [McEwen & Wiaux symmetric sampling] }
  'J_min'           = { Minimum wavelet scale to consider;
                        0 <= J_min < log_B(L) (default=0) }
  'OriginalSpin' = [integer; if the SpinLowered option is used, this
                       option indicates which spin number the wavelets
                       should be lowered from (default = 0)]

 S2LET package to perform Wavelets transform on the Sphere.
 Copyright (C) 2012-2015  Boris Leistedt & Jason McEwen
 See LICENSE.txt for license details

0001 function f = s2let_transform_synthesis_mw(f_wav, f_scal, varargin)
0002 
0003 % s2let_transform_synthesis_mw
0004 % Compute spin directional wavelet transform, output in pixel space.
0005 %
0006 % Default usage :
0007 %
0008 %   f = s2let_transform_synthesis_mw(f_wav, f_scal, <options>)
0009 %
0010 % f_wav contains the input wavelet contributions -- MW sampling,
0011 % f_scal contains the input scaling contributions -- MW sampling,
0012 % f is the output field -- MW sampling,
0013 %
0014 % Option :
0015 %  'Reality'         = { false        [do not assume f real (default)],
0016 %                        true         [assume f real (improves performance)] }
0017 %  'B'               = { Dilation factor; B > 1 (default=2) }
0018 %  'L'               = { Harmonic band-limit; L > 1 (default=guessed from input) }
0019 %  'N'               = { Azimuthal/directional band-limit; N > 1 (default=L) }
0020 %  'Spin'               = { Spin; (default=0) }
0021 %  'Upsample'      = { false        [multiresolution algorithm (default)],
0022 %                      true       [full resolution wavelets] }
0023 %  'Sampling'        = { 'MW'           [McEwen & Wiaux sampling (default)],
0024 %                        'MWSS'         [McEwen & Wiaux symmetric sampling] }
0025 %  'J_min'           = { Minimum wavelet scale to consider;
0026 %                        0 <= J_min < log_B(L) (default=0) }
0027 %  'OriginalSpin' = [integer; if the SpinLowered option is used, this
0028 %                       option indicates which spin number the wavelets
0029 %                       should be lowered from (default = 0)]
0030 %
0031 % S2LET package to perform Wavelets transform on the Sphere.
0032 % Copyright (C) 2012-2015  Boris Leistedt & Jason McEwen
0033 % See LICENSE.txt for license details
0034 
0035 len = size(f_wav);
0036 temp = f_wav{len};
0037 sz = size(temp);
0038 if sz(1) == 2*sz(2)-1 || sz(2) == 2*sz(1)-1
0039     Lguessed = min([sz(1) sz(2)]);
0040 else
0041     Lguessed = min([sz(1) sz(2)])-1;
0042 end
0043 
0044 p = inputParser;
0045 p.addRequired('f_wav');
0046 p.addRequired('f_scal', @isnumeric);
0047 p.addParamValue('B', 2, @isnumeric);
0048 p.addParamValue('L', Lguessed, @isnumeric);
0049 p.addParamValue('J_min', 0, @isnumeric);
0050 p.addParamValue('N', Lguessed, @isnumeric);
0051 p.addParamValue('Spin', 0, @isnumeric);
0052 p.addParamValue('Upsample', false, @islogical);
0053 p.addParamValue('Sampling', 'MW', @ischar);
0054 p.addParamValue('Reality', false, @islogical);
0055 p.addParamValue('OriginalSpin', 0, @isnumeric);
0056 p.parse(f_wav, f_scal, varargin{:});
0057 args = p.Results;
0058 
0059 if  strcmp(args.Sampling, 'MWSS')
0060     f_scal_vec = s2let_mwss_arr2vec(f_scal);
0061 else
0062     f_scal_vec = s2let_mw_arr2vec(f_scal);
0063 end
0064 
0065 if(all(isreal(f_scal_vec)))
0066   f_scal_vec = complex(f_scal_vec,0);
0067 end
0068 J = s2let_jmax(args.L, args.B);
0069 
0070 f_wav_vec = [];
0071 
0072 offset = 0;
0073 for j = args.J_min:J
0074   for en = 1:args.N
0075     if args.Upsample
0076         band_limit = args.L;
0077     else
0078         band_limit = min([ s2let_bandlimit(j,args.J_min,args.B,args.L) args.L ]);
0079     end
0080     temp = f_wav{j+1-args.J_min, en};
0081 
0082     if  strcmp(args.Sampling, 'MWSS')
0083         for t = 1:band_limit+1
0084             for p = 1:2*band_limit
0085                ind = offset + (t-1) * 2 * band_limit + p;
0086                 f_wav_vec = [f_wav_vec temp(t,p)];
0087             end
0088         end
0089         offset = offset + (band_limit+1) * 2 * band_limit;
0090     else
0091         for t = 1:band_limit
0092             for p = 1:2*band_limit-1
0093               ind = offset + (t-1) * ( 2 * band_limit - 1) + p;
0094               f_wav_vec = [f_wav_vec temp(t,p)];
0095             end
0096         end
0097         offset = offset + band_limit * (2 * band_limit - 1);
0098     end
0099   end
0100 end
0101 
0102 if(all(isreal(f_wav_vec)))
0103   f_wav_vec = complex(f_wav_vec,0);
0104 end
0105 
0106 f_vec = s2let_transform_synthesis_mw_mex(f_wav_vec, f_scal_vec, args.B, args.L, args.J_min, ...
0107                                          args.N, args.Spin, args.Reality, args.Upsample, ...
0108                                          args.OriginalSpin, ...
0109                                          args.Sampling);
0110 
0111 if  strcmp(args.Sampling, 'MWSS')
0112     f = s2let_mwss_vec2arr(f_vec);
0113 else
0114     f = s2let_mw_vec2arr(f_vec);
0115 end
0116 
0117 
0118 end