void LTFAT_NAME(ltfatMexFnc)( int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[] )
{
int a, M, N, L, W, s0, s1, br;
// Get matrix dimensions.
L = mxGetM(prhs[0]);
W = mxGetN(prhs[0]);
a = (int)mxGetScalar(prhs[2]);
M = (int)mxGetScalar(prhs[3]);
s0 = (int)mxGetScalar(prhs[4]);
s1 = (int)mxGetScalar(prhs[5]);
br = (int)mxGetScalar(prhs[6]);
N = L/a;
mwSize dims[]= { M, N, W};
mwSize ndim=W>1?3:2;
plhs[0] = ltfatCreateNdimArray(ndim,dims,LTFAT_MX_CLASSID,mxCOMPLEX);
const LTFAT_COMPLEX* f_combined = (const LTFAT_COMPLEX*) mxGetData(prhs[0]);
const LTFAT_COMPLEX* g_combined = (const LTFAT_COMPLEX*) mxGetData(prhs[1]);
LTFAT_COMPLEX* out_combined = (LTFAT_COMPLEX*) mxGetData(plhs[0]);
LTFAT_NAME(dgt_shear)(f_combined,g_combined,L,W,a,M,s0,s1,br,out_combined);
}
void LTFAT_NAME(ltfatMexFnc)( int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[] )
{
int L, W, a, M, N;
mwSize ndim;
mwSize dims[3];
// Get matrix dimensions.
L = mxGetM(prhs[0]);
W = mxGetN(prhs[0]);
a=(int)mxGetScalar(prhs[2]);
M=(int)mxGetScalar(prhs[3]);
N=L/a;
dims[0]=M;
dims[1]=N;
dims[2]=W;
ndim=3;
if (W==1)
{
ndim=2;
}
plhs[0] = ltfatCreateNdimArray(ndim,dims,LTFAT_MX_CLASSID,mxCOMPLEX);
const LTFAT_REAL _Complex* f_combined = (const LTFAT_REAL _Complex*) mxGetData(prhs[0]);
const LTFAT_REAL _Complex* g_combined = (const LTFAT_REAL _Complex*) mxGetData(prhs[1]);
LTFAT_REAL _Complex* out_combined = (LTFAT_REAL _Complex*) mxGetData(plhs[0]);
LTFAT_NAME(dgt_long)((const LTFAT_REAL (*)[2])f_combined,
(const LTFAT_REAL (*)[2])g_combined,
L,W,a,M,(LTFAT_REAL (*)[2])out_combined);
return;
}
void LTFAT_NAME(ltfatMexFnc)( int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[] )
{
// UGLY, but there are no cd_dwilt_long cs_dwilt_long functions
// Other option is to use forwarder functions
#undef LTFAT_NAME
#ifdef LTFAT_SINGLE
# define LTFAT_NAME(name) LTFAT_NAME_SINGLE(name)
#else
# define LTFAT_NAME(name) LTFAT_NAME_DOUBLE(name)
#endif
int M, N, L, W;
mwSize ndim;
mwSize dims[3];
// Get matrix dimensions.
M=(int)mxGetScalar(prhs[2]);
L=(int)mxGetScalar(prhs[3]);
W = mxGetN(prhs[0]);
N=L/M;
dims[0]=2*M;
dims[1]=N/2;
if (W==1)
{
ndim=2;
}
else
{
ndim=3;
dims[2]=W;
}
plhs[0] = ltfatCreateNdimArray(ndim,dims,LTFAT_MX_CLASSID,LTFAT_MX_COMPLEXITY);
const LTFAT_TYPE* f = (const LTFAT_TYPE*) mxGetData(prhs[0]);
const LTFAT_TYPE* g = (const LTFAT_TYPE*) mxGetData(prhs[1]);
LTFAT_TYPE* cout = (LTFAT_TYPE*) mxGetData(plhs[0]);
#ifdef LTFAT_COMPLEXTYPE
LTFAT_NAME(dwilt_long)((const LTFAT_REAL (*)[2])f,
(const LTFAT_REAL (*)[2])g,
L, W, M,
(LTFAT_REAL (*)[2]) cout);
#else
LTFAT_NAME(dwiltreal_long)(f,g,L, W, M, cout);
#endif
return;
}
void LTFAT_NAME(ltfatMexFnc)( int UNUSED(nlhs), mxArray* plhs[],
int UNUSED(nrhs), const mxArray* prhs[] )
{
// Get inputs
const mxArray* mxs = prhs[0];
const LTFAT_REAL* s = mxGetData(mxs);
const LTFAT_REAL* tgrad = mxGetData(prhs[1]);
const LTFAT_REAL* fgrad = mxGetData(prhs[2]);
const double* maskDouble = mxGetData(prhs[3]);
mwSize a = (mwSize)mxGetScalar(prhs[4]);
LTFAT_REAL tol = (LTFAT_REAL)mxGetScalar(prhs[6]);
const LTFAT_REAL* knownphase = mxGetData(prhs[8]);
int phasetype = (int)mxGetScalar(prhs[7]);
switch (phasetype)
{
case 0: phasetype = LTFAT_FREQINV; break;
case 1: phasetype = LTFAT_TIMEINV; break;
}
// Get matrix dimensions.
mwSize M = (int) mxGetScalar(prhs[5]);
mwSize M2 = mxGetM(prhs[0]);
mwSize N = ltfatGetN(prhs[0]);
mwSize L = N * a;
mwSize W = 1;
if (mxGetNumberOfDimensions(mxs) > 2)
W = mxGetDimensions(mxs)[2];
int* mask = ltfat_malloc(M2 * N * W * sizeof * mask);
for (mwSize w = 0; w < M2 * N * W; w++ )
mask[w] = (int) maskDouble[w];
// Create output matrix and zero it.
plhs[0] = ltfatCreateNdimArray(mxGetNumberOfDimensions(mxs),
mxGetDimensions(mxs),
LTFAT_MX_CLASSID, mxREAL);
// Get pointer to output
LTFAT_REAL* phase = mxGetData(plhs[0]);
memcpy(phase, knownphase, M2 * N * W * sizeof * phase);
if (phasetype == 2)
LTFAT_NAME(maskedheapintreal)(s, tgrad, fgrad, mask, a, M, L, W, tol,
phase );
else
LTFAT_NAME(maskedheapintreal_relgrad)(s, tgrad, fgrad, mask, a, M, L, W,
tol, phasetype, phase );
ltfat_free(mask);
}
/*
%COMP_ATROUSFILTERBANK_TD Uniform filterbank by conv2
% Usage: c=comp_atrousfilterbank_fft(f,g,a,offset);
%
% Input parameters:
% f : Input data - L*W array.
% g : Filterbank filters - filtLen*M array.
% a : Filter upsampling factor - scalar.
% offset: Delay of the filters - scalar or array of length M.
%
% Output parameters:
% c : L*M*W array of coefficients
%
*/
void LTFAT_NAME(ltfatMexFnc)( int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[] )
{
const mxArray* mxf = prhs[0];
const mxArray* mxg = prhs[1];
double* a = mxGetPr(prhs[2]);
double* offset = mxGetPr(prhs[3]);
// input data length
unsigned int L = mxGetM(mxf);
// number of channels
unsigned int W = mxGetN(mxf);
// filter number
unsigned int M = mxGetN(mxg);
// filter length
unsigned int filtLen = mxGetM(mxg);
// POINTER TO THE INPUT
LTFAT_TYPE* fPtr = (LTFAT_TYPE*) mxGetPr(prhs[0]);
// POINTER TO THE FILTERS
LTFAT_TYPE** gPtrs = (LTFAT_TYPE**) mxMalloc(M*sizeof(LTFAT_TYPE*));
for(unsigned int m=0; m<M; m++)
{
gPtrs[m] = ((LTFAT_TYPE*) mxGetData(mxg)) + m*filtLen;
}
mwSize ndim = 3;
mwSize dims[3];
dims[0] = L;
dims[1] = M;
dims[2] = W;
plhs[0] = ltfatCreateNdimArray(ndim,dims,LTFAT_MX_CLASSID,LTFAT_MX_COMPLEXITY);
// over all filters
for(unsigned int m =0; m<M; m++)
{
// over all channels
for(unsigned int w =0; w<W; w++)
{
// Obtain pointer to w-th column in input
LTFAT_TYPE *fPtrCol = fPtr + w*L;
LTFAT_TYPE *cPtrPlane = ((LTFAT_TYPE*) mxGetData(plhs[0])) + w*L*M;
// Obtaing pointer to w-th column in m-th element of output cell-array
LTFAT_TYPE *cPtrCol = cPtrPlane + m*L;
LTFAT_NAME(atrousconvsub_td)(fPtrCol, L, cPtrCol, L, gPtrs[m], filtLen, (int)*a, -offset[m], ltfatExtStringToEnum("per"));
}
}
}
/*
%COMP_ATROUSFILTERBANK_TD Uniform filterbank by conv2
% Usage: c=comp_atrousfilterbank_td(f,g,a,offset);
%
% Input parameters:
% f : Input data - L*W array.
% g : Filterbank filters - filtLen*M array.
% a : Filter upsampling factor - scalar.
% offset: Delay of the filters - scalar or array of length M.
%
% Output parameters:
% c : L*M*W array of coefficients
%
*/
void LTFAT_NAME(ltfatMexFnc)( int UNUSED(nlhs), mxArray *plhs[],
int UNUSED(nrhs), const mxArray *prhs[] )
{
const mxArray* mxf = prhs[0];
const mxArray* mxg = prhs[1];
double* aDouble = mxGetPr(prhs[2]);
double* offsetDouble = mxGetPr(prhs[3]);
// input data length
mwSize L = mxGetM(mxf);
// number of channels
mwSize W = mxGetN(mxf);
// filter number
mwSize M = mxGetN(mxg);
// filter length
mwSize filtLen = mxGetM(mxg);
// POINTER TO THE INPUT
LTFAT_TYPE* fPtr = mxGetData(prhs[0]);
// POINTER TO THE FILTERS
const LTFAT_TYPE* gPtrs[M];
ltfatInt offset[M];
ltfatInt a[M];
ltfatInt filtLens[M];
for(mwSize m=0; m<M; m++)
{
filtLens[m] = filtLen;
a[m] = *aDouble;
offset[m] = offsetDouble[m];
gPtrs[m] = ((LTFAT_TYPE*) mxGetData(mxg)) + m*filtLen;
}
mwSize ndim = 3;
mwSize dims[]= {L, M, W};
plhs[0] = ltfatCreateNdimArray(ndim,dims,
LTFAT_MX_CLASSID,LTFAT_MX_COMPLEXITY);
LTFAT_TYPE* cPtr = mxGetData(plhs[0]);
LTFAT_NAME(atrousfilterbank_td)(fPtr, gPtrs, L, filtLens,
W, a, offset, M, cPtr, PER);
}
