void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum { X=0,Y } ;
enum { U } ;
int NP, NCP ;
int i,j ;
double *X_pt, *Y_pt, *U_pt ;
#undef small
const double small = 2.220446049250313e-16 ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin != 2) {
vlmxError(vlmxErrNotEnoughInputArguments, NULL) ;
} else if (nout > 1) {
vlmxError(vlmxErrTooManyOutputArguments, NULL) ;
}
if(!vlmxIsMatrix(in[X], 2, -1)) {
mexErrMsgTxt("X must be a 2xNP real matrix") ;
}
if(!vlmxIsMatrix(in[Y], 2, -1)) {
mexErrMsgTxt("Y must be a 2xNCP real matrix") ;
}
NP = getN(X) ;
NCP = getN(Y) ;
X_pt = getPr(X);
Y_pt = getPr(Y) ;
/* Allocate the result. */
out[U] = mxCreateDoubleMatrix(NP, NCP, mxREAL) ;
U_pt = mxGetPr(out[U]) ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
for(j = 0 ; j < NCP ; ++j) {
double xcp = *Y_pt++ ;
double ycp = *Y_pt++ ;
for(i = 0 ; i < NP ; ++i) {
double dx = *X_pt++ - xcp ;
double dy = *X_pt++ - ycp ;
double r2 = dx*dx + dy*dy ;
*U_pt++ = (r2 <= small) ? 0 : r2 * log (r2) ;
}
X_pt -= 2*NP ;
}
}
double
CSlmBuilder::getPr(int n, TSIMWordId *words)
{
int lvl;
double bow = 1.0;
void* pnode = &((*(TNodeLevel*)level[0])[0]);
assert(n <= nlevel);
if (n == 0) {
if (bUseLogPr) {
return exp(-((TNode*)pnode)->pr);
} else {
return ((TNode*)pnode)->pr;
}
}
for (lvl = 0; pnode != NULL && lvl < n; ++lvl) {
if (bUseLogPr) {
bow = exp(-((TNode*)pnode)->bow);
} else {
bow = ((TNode*)pnode)->bow;
}
pnode = FindChild(lvl, (TNode*)pnode, words[lvl]);
}
if (pnode != NULL) { // find the whole string
if (bUseLogPr) {
return exp(-((TLeaf*)pnode)->pr);
} else {
return ((TLeaf*)pnode)->pr;
}
} else if (lvl == n - 1) { // only find the history
return bow * getPr(n - 1, words + 1);
} else { //even not find the history
return getPr(n - 1, words + 1);
}
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum { X=0,Y,I,iwXp,iwYp } ;
enum { wI=0, wIx, wIy } ;
int M, N, Mp, Np, ip, jp ;
double
*X_pt,
*Y_pt,
*I_pt,
*iwXp_pt,
*iwYp_pt,
*wI_pt,
*wIx_pt = 0,
*wIy_pt = 0 ;
double Xmin, Xmax, Ymin, Ymax ;
const double NaN = mxGetNaN() ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin < 5) {
vlmxError (vlmxErrNotEnoughInputArguments, NULL) ;
}
if (nin > 5) {
vlmxError (vlmxErrTooManyOutputArguments, NULL) ;
}
if (nout > 3) {
vlmxError (vlmxErrTooManyOutputArguments, NULL) ;
}
if (! vlmxIsPlainMatrix(in[I], -1, -1)) {
vlmxError (vlmxErrInvalidArgument, "I is not a plain matrix.") ;
}
if (! vlmxIsPlainMatrix(in[iwXp], -1, -1)) {
vlmxError(vlmxErrInvalidArgument, "iwXp is not a plain matrix.") ;
}
M = getM(I) ;
N = getN(I) ;
Mp = getM(iwXp) ;
Np = getN(iwXp) ;
if(!vlmxIsPlainMatrix(in[iwYp], Mp, Np)) {
vlmxError(vlmxErrInvalidArgument,
"iwXp is not a plain matrix of the same idmension of iwYp.") ;
}
if(!vlmxIsPlainVector(in[X],N) || !vlmxIsPlainVector(in[Y],M)) {
vlmxError(vlmxErrInvalidArgument,
"X and Y are not plain vectors with a length equal to the"
" number of columns and rows of I.") ;
}
X_pt = getPr(X);
Y_pt = getPr(Y) ;
I_pt = getPr(I) ;
iwXp_pt = getPr(iwXp) ;
iwYp_pt = getPr(iwYp) ;
/* Allocate the result. */
out[wI] = mxCreateDoubleMatrix(Mp, Np, mxREAL) ;
wI_pt = mxGetPr(out[wI]) ;
if (nout > 1) {
out[wIx] = mxCreateDoubleMatrix(Mp, Np, mxREAL) ;
out[wIy] = mxCreateDoubleMatrix(Mp, Np, mxREAL) ;
wIx_pt = mxGetPr (out[wIx]) ;
wIy_pt = mxGetPr (out[wIy]) ;
}
/* -----------------------------------------------------------------
* Do the job
* -------------------------------------------------------------- */
Xmin = X_pt [0] ;
Xmax = X_pt [N - 1] ;
Ymin = Y_pt [0] ;
Ymax = Y_pt [M - 1] ;
if (nout <= 1) {
/* optimized for only image output */
for(jp = 0 ; jp < Np ; ++jp) {
for(ip = 0 ; ip < Mp ; ++ip) {
/* Search for the four neighbors of the backprojected point. */
double x = *iwXp_pt++ ;
double y = *iwYp_pt++ ;
double z = NaN ;
/* This messy code allows the identity transformation
* to be processed as expected. */
if(x >= Xmin && x <= Xmax &&
y >= Ymin && y <= Ymax) {
int j = findNeighbor(x, X_pt, N) ;
int i = findNeighbor(y, Y_pt, M) ;
double* pt = I_pt + j*M + i ;
/* Weights. */
double x0 = X_pt[j] ;
double x1 = (j < N-1) ? X_pt[j+1] : x0 + 1;
double y0 = Y_pt[i] ;
double y1 = (i < M-1) ? Y_pt[i+1] : y0 + 1;
double wx = (x-x0)/(x1-x0) ;
double wy = (y-y0)/(y1-y0) ;
/* Load all possible neighbors. */
double z00 = 0.0 ;
double z10 = 0.0 ;
double z01 = 0.0 ;
double z11 = 0.0 ;
if(j > -1) {
if(i > -1 ) z00 = *pt ;
pt++ ;
if(i < M-1) z10 = *pt ;
} else {
pt++ ;
}
pt += M - 1;
if(j < N-1) {
if(i > -1 ) z01 = *pt ;
pt++ ;
if(i < M-1) z11 = *pt ;
}
/* Bilinear interpolation. */
z =
(1 - wy) * ((1-wx) * z00 + wx * z01) +
( wy) * ((1-wx) * z10 + wx * z11) ;
}
*(wI_pt + jp*Mp + ip) = z ;
}
}
}
/* do also the derivatives */
else {
/* optimized for only image output */
for(jp = 0 ; jp < Np ; ++jp) {
for(ip = 0 ; ip < Mp ; ++ip) {
/* Search for the four neighbors of the backprojected point. */
double x = *iwXp_pt++ ;
double y = *iwYp_pt++ ;
double z = NaN, zx = NaN, zy = NaN ;
/* This messy code allows the identity transformation
* to be processed as expected. */
if(x >= Xmin && x <= Xmax &&
y >= Ymin && y <= Ymax) {
int j = findNeighbor(x, X_pt, N) ;
int i = findNeighbor(y, Y_pt, M) ;
double* pt = I_pt + j*M + i ;
/* Weights. */
double x0 = X_pt[j] ;
double x1 = X_pt[j+1] ;
double y0 = Y_pt[i] ;
double y1 = Y_pt[i+1] ;
double wx = (x-x0)/(x1-x0) ;
double wy = (y-y0)/(y1-y0) ;
/* Load all possible neighbors. */
double z00 = 0.0 ;
double z10 = 0.0 ;
double z01 = 0.0 ;
double z11 = 0.0 ;
if(j > -1) {
if(i > -1 ) z00 = *pt ;
pt++ ;
if(i < M-1) z10 = *pt ;
} else {
pt++ ;
}
pt += M - 1;
if(j < N-1) {
if(i > -1 ) z01 = *pt ;
pt++ ;
if(i < M-1) z11 = *pt ;
}
/* Bilinear interpolation. */
z =
(1-wy)*( (1-wx) * z00 + wx * z01) +
wy*( (1-wx) * z10 + wx * z11) ;
zx =
(1-wy) * (z01 - z00) +
wy * (z11 - z10) ;
zy =
(1-wx) * (z10 - z00) +
wx * (z11 - z01) ;
}
*(wI_pt + jp*Mp + ip) = z ;
*(wIx_pt + jp*Mp + ip) = zx ;
*(wIy_pt + jp*Mp + ip) = zy ;
}
}
}
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum { X=0,Y,I,iwXp,iwYp } ;
enum { wI=0, wIx, wIy } ;
int M, N, Mp, Np, ip, jp ;
double
*X_pt,
*Y_pt,
*I_pt,
*iwXp_pt,
*iwYp_pt,
*wI_pt,
*wIx_pt = 0,
*wIy_pt = 0 ;
double Xmin, Xmax, Ymin, Ymax ;
const double NaN = mxGetNaN() ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if(nin != 5) {
mexErrMsgTxt("Five input argumets required.") ;
}
if (nout > 3) {
mexErrMsgTxt("Too many output arguments") ;
}
if(!uIsRealMatrix(in[I], -1, -1)) {
mexErrMsgTxt("I must be a real matrix of class DOUBLE") ;
}
if(!uIsRealMatrix(in[iwXp], -1, -1)) {
mexErrMsgTxt("iwXp must be a real matrix") ;
}
M = getM(I) ;
N = getN(I) ;
Mp = getM(iwXp) ;
Np = getN(iwXp) ;
if(!uIsRealMatrix(in[iwYp], Mp, Np)) {
mexErrMsgTxt
("iwXp and iwYp must be a real matrices of the same dimension") ;
}
if(!uIsRealVector(in[X],N) || !uIsRealVector(in[Y],M)) {
mexErrMsgTxt
("X and Y must be vectors of the same dimensions "
"of the columns/rows of I, respectivelye") ;
}
X_pt = getPr(X);
Y_pt = getPr(Y) ;
I_pt = getPr(I) ;
iwXp_pt = getPr(iwXp) ;
iwYp_pt = getPr(iwYp) ;
/* Allocate the result. */
out[wI] = mxCreateDoubleMatrix(Mp, Np, mxREAL) ;
wI_pt = mxGetPr(out[wI]) ;
if (nout > 1) {
out[wIx] = mxCreateDoubleMatrix(Mp, Np, mxREAL) ;
out[wIy] = mxCreateDoubleMatrix(Mp, Np, mxREAL) ;
wIx_pt = mxGetPr (out[wIx]) ;
wIy_pt = mxGetPr (out[wIy]) ;
}
/* -----------------------------------------------------------------
* Do the job
* -------------------------------------------------------------- */
Xmin = X_pt [0] ;
Xmax = X_pt [N - 1] ;
Ymin = Y_pt [0] ;
Ymax = Y_pt [M - 1] ;
if (nout <= 1) {
/* optimized for only image output */
for(jp = 0 ; jp < Np ; ++jp) {
for(ip = 0 ; ip < Mp ; ++ip) {
/* Search for the four neighbors of the backprojected point. */
double x = *iwXp_pt++ ;
double y = *iwYp_pt++ ;
double z = NaN ;
/* This messy code allows the identity transformation
* to be processed as expected. */
if(x >= Xmin && x <= Xmax &&
y >= Ymin && y <= Ymax) {
int j = findNeighbor(x, X_pt, N) ;
int i = findNeighbor(y, Y_pt, M) ;
double* pt = I_pt + j*M + i ;
/* Weights. */
double x0 = X_pt[j] ;
double x1 = X_pt[j+1] ;
double y0 = Y_pt[i] ;
double y1 = Y_pt[i+1] ;
double wx = (x-x0)/(x1-x0) ;
double wy = (y-y0)/(y1-y0) ;
/* Load all possible neighbors. */
double z00 = 0.0 ;
double z10 = 0.0 ;
double z01 = 0.0 ;
double z11 = 0.0 ;
if(j > -1) {
if(i > -1 ) z00 = *pt ;
pt++ ;
if(i < M-1) z10 = *pt ;
} else {
pt++ ;
}
pt += M - 1;
if(j < N-1) {
if(i > -1 ) z01 = *pt ;
pt++ ;
if(i < M-1) z11 = *pt ;
}
/* Bilinear interpolation. */
z =
(1 - wy) * ((1-wx) * z00 + wx * z01) +
( wy) * ((1-wx) * z10 + wx * z11) ;
}
*(wI_pt + jp*Mp + ip) = z ;
}
}
}
/* do also the derivatives */
else {
/* optimized for only image output */
for(jp = 0 ; jp < Np ; ++jp) {
for(ip = 0 ; ip < Mp ; ++ip) {
/* Search for the four neighbors of the backprojected point. */
double x = *iwXp_pt++ ;
double y = *iwYp_pt++ ;
double z = NaN, zx = NaN, zy = NaN ;
/* This messy code allows the identity transformation
* to be processed as expected. */
if(x >= Xmin && x <= Xmax &&
y >= Ymin && y <= Ymax) {
int j = findNeighbor(x, X_pt, N) ;
int i = findNeighbor(y, Y_pt, M) ;
double* pt = I_pt + j*M + i ;
/* Weights. */
double x0 = X_pt[j] ;
double x1 = X_pt[j+1] ;
double y0 = Y_pt[i] ;
double y1 = Y_pt[i+1] ;
double wx = (x-x0)/(x1-x0) ;
double wy = (y-y0)/(y1-y0) ;
/* Load all possible neighbors. */
double z00 = 0.0 ;
double z10 = 0.0 ;
double z01 = 0.0 ;
double z11 = 0.0 ;
if(j > -1) {
if(i > -1 ) z00 = *pt ;
pt++ ;
if(i < M-1) z10 = *pt ;
} else {
pt++ ;
}
pt += M - 1;
if(j < N-1) {
if(i > -1 ) z01 = *pt ;
pt++ ;
if(i < M-1) z11 = *pt ;
}
/* Bilinear interpolation. */
z =
(1-wy)*( (1-wx) * z00 + wx * z01) +
wy*( (1-wx) * z10 + wx * z11) ;
zx =
(1-wy) * (z01 - z00) +
wy * (z11 - z10) ;
zy =
(1-wx) * (z10 - z00) +
wx * (z11 - z01) ;
}
*(wI_pt + jp*Mp + ip) = z ;
*(wIx_pt + jp*Mp + ip) = zx ;
*(wIy_pt + jp*Mp + ip) = zy ;
}
}
}
}
