Matrix2 psf2otf(Matrix& psf, Matrix& outSize)
{
Matrix psfSize(1, 2);
psfSize(0, 0) = psf.size1();
psfSize(0, 1) = psf.size2();
Matrix padSize(1, 2);
padSize = outSize - psfSize;
psf = padarray(psf, padSize);
psf = circshift(psf, -Matfloor(psfSize / 2));
Matrix2 otf = fft2(psf);
return otf;
}
//
// Arguments : const emxArray_real_T *I
// emxArray_real_T *I2
// Return Type : void
//
void fillimg(const emxArray_real_T *I, emxArray_real_T *I2)
{
emxArray_real_T *mask;
int i16;
int b_mask;
int c_mask;
emxArray_real_T *marker;
b_emxInit_real_T(&mask, 2);
padarray(I, mask);
i16 = mask->size[0] * mask->size[1];
emxEnsureCapacity((emxArray__common *)mask, i16, (int)sizeof(double));
b_mask = mask->size[0];
c_mask = mask->size[1];
b_mask *= c_mask;
for (i16 = 0; i16 < b_mask; i16++) {
mask->data[i16] = 1.0 - mask->data[i16];
}
b_emxInit_real_T(&marker, 2);
i16 = marker->size[0] * marker->size[1];
marker->size[0] = mask->size[0];
marker->size[1] = mask->size[1];
emxEnsureCapacity((emxArray__common *)marker, i16, (int)sizeof(double));
b_mask = mask->size[0] * mask->size[1];
for (i16 = 0; i16 < b_mask; i16++) {
marker->data[i16] = mask->data[i16];
}
for (b_mask = 0; b_mask <= mask->size[0] - 3; b_mask++) {
i16 = marker->size[1];
for (c_mask = 0; c_mask <= i16 - 3; c_mask++) {
marker->data[(b_mask + marker->size[0] * (c_mask + 1)) + 1] = rtMinusInf;
}
}
i16 = I2->size[0] * I2->size[1];
I2->size[0] = marker->size[0];
I2->size[1] = marker->size[1];
emxEnsureCapacity((emxArray__common *)I2, i16, (int)sizeof(double));
b_mask = marker->size[0] * marker->size[1];
for (i16 = 0; i16 < b_mask; i16++) {
I2->data[i16] = marker->data[i16];
}
imreconstruct(I2, mask);
i16 = I2->size[0] * I2->size[1];
emxEnsureCapacity((emxArray__common *)I2, i16, (int)sizeof(double));
b_mask = I2->size[0];
c_mask = I2->size[1];
b_mask *= c_mask;
for (i16 = 0; i16 < b_mask; i16++) {
I2->data[i16] = 1.0 - I2->data[i16];
}
b_mask = marker->size[0] - 2;
i16 = mask->size[0] * mask->size[1];
mask->size[0] = b_mask;
emxEnsureCapacity((emxArray__common *)mask, i16, (int)sizeof(double));
b_mask = marker->size[1] - 2;
i16 = mask->size[0] * mask->size[1];
mask->size[1] = b_mask;
emxEnsureCapacity((emxArray__common *)mask, i16, (int)sizeof(double));
b_mask = (marker->size[0] - 2) * (marker->size[1] - 2);
for (i16 = 0; i16 < b_mask; i16++) {
mask->data[i16] = 0.0;
}
for (b_mask = 0; b_mask <= marker->size[0] - 3; b_mask++) {
for (c_mask = 0; c_mask <= marker->size[1] - 3; c_mask++) {
mask->data[b_mask + mask->size[0] * c_mask] = I2->data[(b_mask + I2->size
[0] * (c_mask + 1)) + 1];
}
}
emxFree_real_T(&marker);
i16 = I2->size[0] * I2->size[1];
I2->size[0] = mask->size[0];
I2->size[1] = mask->size[1];
emxEnsureCapacity((emxArray__common *)I2, i16, (int)sizeof(double));
b_mask = mask->size[0] * mask->size[1];
for (i16 = 0; i16 < b_mask; i16++) {
I2->data[i16] = mask->data[i16];
}
emxFree_real_T(&mask);
}
// Given the image of a person, get the axes, and return the map of kernel;
cv::Mat ReidDescriptor::map_kernel(cv::Mat img, int delta1, int delta2, float alpha, float varW, int H, int W, int &TLanti, int &HDanti,cv::Mat MSK)
{
// UPLOADING AND FEATURE EXTRACTION
if(MSK.empty()) {
MSK = cv::Mat::ones(cv::Size(W, H), CV_8U);
}
// (me) Wouldn't it be quicker to just create a image of the same size rather than clone it ?
cv::Mat img_hsv = img.clone();
// Matlab:0:1,0:1,0:1 ; Opencv:0:255,0:255,0:180
cv::Mat img_cielab = img.clone();
// Matlab:0:255,0:255,0:255 ; Opencv:0:255,0:255,0:255
cvtColor(img, img_hsv, CV_BGR2HSV);
cvtColor(img, img_cielab, CV_BGR2Lab);
// (me) Normalisation...?
vector<cv::Mat> temp;
split(img_hsv, temp);
temp[0].convertTo(temp[0], CV_32FC1, 1 / 180.f);
temp[1].convertTo(temp[1], CV_32FC1, 1 / 255.f);
temp[2].convertTo(temp[2], CV_32FC1, 1 / 255.f);
merge(temp, img_hsv);
//double m, M;
//cv::minMaxLoc(img_hsv,&m,&M);
//imshow("imghsv",temp[0]);
//cv::normalize(img_hsv,img_hsv,CV_MINMAX);
TLanti = fminbnd(dissym_div, img_hsv, MSK, delta1, alpha, delta1, H - delta1);
//cout << dissym_div(33, img_hsv, MSK, delta1, alpha)<<endl;
//cout << dissym_div(34, img_hsv, MSK, delta1, alpha) << endl;
int BUsim = fminbnd(sym_div, img_hsv.rowRange(0, img_hsv.rows), MSK.rowRange(0, img_hsv.rows), delta2, alpha, delta2, W - delta2);
//cout << sym_div(18, img_hsv.rowRange(0, TLanti + 1), MSK.rowRange(0, TLanti + 1), delta2, alpha) << endl;
//cout << sym_div(35, img_hsv.rowRange(0, TLanti + 1), MSK.rowRange(0, TLanti + 1), delta2, alpha) << endl;
//int LEGsim = fminbnd(sym_div, img_hsv.rowRange(TLanti, img_hsv.rows), MSK.rowRange(TLanti, MSK.rows), delta2, alpha, delta2, W - delta2);
HDanti = fminbnd(sym_dissimilar_MSKH, img_hsv, MSK, delta1, 0, 5, TLanti);
//cv::Mat img_show = img.clone();
//line(img_show, cv::Point(0, TLanti), cv::Point(W, TLanti), cv::Scalar(255, 0, 0));
//line(img_show, cv::Point(0, HDanti), cv::Point(W, HDanti), cv::Scalar(255, 0, 0));
//line(img_show, cv::Point(BUsim, HDanti), cv::Point(BUsim, TLanti), cv::Scalar(255, 0, 0));
//line(img_show, cv::Point(LEGsim, TLanti), cv::Point(LEGsim, H), cv::Scalar(255, 0, 0));
//imshow("test", img_show);
//cv::waitKey(0);
// Kernel - map computation
vector<cv::Mat> img_split;
split(img_hsv, img_split);
img_split[2].convertTo(img_split[2], CV_8UC1, 255);
equalizeHist(img_split[2], img_split[2]);
img_split[2].convertTo(img_split[2], CV_32FC1, 1.0 / 255);
merge(img_split, img_hsv);
//cv::Mat HEADW = cv::Mat::zeros(cv::Size(W, HDanti + 1), CV_32FC1);
//cv::Mat UP = img_hsv.rowRange(HDanti + 1, TLanti + 1);
cv::Mat UP = img_hsv.rowRange(0, img_hsv.rows);
cv::Mat UPW = gau_kernel(BUsim, varW, UP.rows, W);
//cv::Mat DOWN = img_hsv.rowRange(TLanti + 1, img_hsv.rows);
//cv::Mat DOWNW = gau_kernel(LEGsim, varW, DOWN.rows, W);
cv::Mat MAP_KRNL = UPW / max_value(UPW);
//cv::Mat MAP_KRNL = HEADW.clone() / max_value(HEADW);
//MAP_KRNL.push_back(cv::Mat(UPW / max_value(UPW)));
//MAP_KRNL.push_back(cv::Mat(DOWNW / max_value(DOWNW)));
if (H - MAP_KRNL.rows > 0) {
MAP_KRNL = padarray(MAP_KRNL, H - MAP_KRNL.rows);
} else {
MAP_KRNL = MAP_KRNL.rowRange(0, H);
}
//cv::imshow("map_kernel", MAP_KRNL);
//cv::waitKey(0);
return MAP_KRNL;
}
/*----------------------------------------------------------------------------------------------------------------------------------------- */
void mlhoee_spyr(double *I , double *H, int ny , int nx , int nH , int dimcolor , struct opts options )
{
double *spyr = options.spyr , *norma = options.norma , *kernelx = options.kernelx , *kernely = options.kernely;
double min_bin , max_bin , diff_bin ;
double bin_size , center_offset , mini_b , f , absf;
double clamp = options.clamp , temp , scaley , scalex, angle , mag , tempsx , tempsy , ratiox , ratioy , maxfactor = 0.0 , ratio;
int i , j , p , l , x , y , o , q , v ;
int kyy = options.kyy , kxy = options.kxy , kyx = options.kyx , kxx = options.kxx , bndori = options.bndori;
int nspyr = options.nspyr , nori = options.nori , norm = options.norm , nori2 = nori - 1 , interpolate = options.interpolate;
int by , bx , ly , lx, pady , padx , nypad , nxpad , nypadnxpad , nynew , nxnew , nynxnew , nx1, ny1 , ny1nx1 , nygrady , nxgrady , nygradx , nxgradx;
int indjx , indjy , indjm , indi , indj , index , indexo , indexp , indtmpx , indtmpy , bin , nhd_bin;
int deltay, deltax, sy , sx, origy, origx , offsety , offsetx , offy , offx , extraoy , extraox , offye , offxe, x0 , y0 , x1 , y1;
int offyx , eyx , offxx , exx , offyy , eyy , offxy , exy , sf;
int nynx = ny*nx , norinH = nori*nH , vnynx , vnorinH;
double *Ipaded;
double *grady , *gradx , *R , *m , *sat , *cell;
if(bndori == 0)
{
min_bin = -PI/2;
max_bin = PI/2;
}
else
{
min_bin = -PI;
max_bin = PI;
}
diff_bin = (max_bin - min_bin);
bin_size = diff_bin/nori;
center_offset = bin_size*0.5;
mini_b = min_bin+center_offset;
for (p = 0 ; p < nspyr ; p++)
{
maxfactor = max(maxfactor , spyr[p + 0]*spyr[p + nspyr]);
}
by = (int) ceil(ny*norma[0]);
bx = (int) ceil(nx*norma[1]);
nynew = ((int) ceil(ny/(double)by))*by;
nxnew = ((int) ceil(nx/(double)bx))*bx;
nynxnew = nynew*nxnew;
ratioy = (nynew - ny)/2.0;
offy = (int) floor(ratioy);
extraoy = (int) ceil((ratioy - offy)/2.0);
offye = offy + extraoy;
ratiox = (nxnew - nx)/2.0;
offx = (int) floor(ratiox);
extraox = (int) ceil((ratiox - offx)/2.0);
offxe = offx + extraox;
/*
pady = max(1 , max(offy , max(kyx , kyy)));
padx = max(1 , max(offx , max(kxx , kxy)));
*/
pady = max(1 , max(offye , max(kyx , kyy)));
padx = max(1 , max(offxe , max(kxx , kxy)));
nypad = ny + 2*pady;
nxpad = nx + 2*padx;
nypadnxpad = nypad*nxpad;
offyx = (int) (floor((kyx + 1)/2));
eyx = 2*offyx - kyx;
offxx = (int) (floor((kxx + 1)/2));
exx = 2*offxx - kxx;
offyy = (int) (floor((kyy + 1)/2));
eyy = 2*offyy - kyy;
offxy = (int) (floor((kxy + 1)/2));
exy = 2*offxy - kxy;
Ipaded = (double *)malloc(nypadnxpad*sizeof(double));
nygrady = nypad + kyy - 1;
nxgrady = nxpad + kxy - 1;
nygradx = nypad + kyx - 1;
nxgradx = nxpad + kxx - 1;
grady = (double *)malloc(nygrady*nxgrady*sizeof(double));
gradx = (double *)malloc(nygradx*nxgradx*sizeof(double));
R = (double *)malloc(nynxnew*nori*sizeof(double));
m = (double *)malloc(nynxnew*sizeof(double));
nx1 = nxnew + 1;
ny1 = nynew + 1;
ny1nx1 = ny1*nx1;
sat = (double *)malloc(ny1nx1*sizeof(double));
cell = (double *)malloc(5*nH*sizeof(double));
for (v = 0 ; v < dimcolor ; v++)
{
vnynx = v*nynx;
vnorinH = v*norinH;
/* Pading */
for(i = 0 ; i < nypadnxpad ; i++)
{
Ipaded[i] = 0.0;
}
padarray(I + vnynx , ny , nx , pady , padx , Ipaded);
/* Gradient computation */
conv2(Ipaded , kernely , nypad , nxpad , kyy , kxy , nygrady , nygrady , grady);
conv2(Ipaded , kernelx , nypad , nxpad , kyx , kxx , nygradx , nxgradx , gradx);
/*
indtmpx = max(0,padx + offxx - exx - offxe);
indtmpy = max(0,pady + offxy - exy - offxe);
indtmpx = padx + offxx - exx - offxe;
indtmpy = pady + offxy - exy - offxe;
*/
indtmpx = max(0,padx + offxx - exx - offxe);
indtmpy = max(0,padx + offxy - exy - offxe);
for (i = 0 ; i < nynxnew*nori ; i++)
{
R[i] = 0.0;
}
if(bndori == 0)
{
for(j = 0 ; j < nxnew ; j++)
{
indjx = pady + offyx - eyx - offye + (j + indtmpx)*nygradx;
indjy = pady + offyy - eyy - offye + (j + indtmpy)*nygrady;
indjm = j*nynew;
for(i = 0 ; i < nynew ; i++)
{
tempsx = gradx[i + indjx];
tempsy = grady[i + indjy];
angle = atan(tempsy/(tempsx + verytiny));
mag = sqrt((tempsx*tempsx) + (tempsy*tempsy));
bin = min(nori2 , max(0 , (int)floor(nori*(angle - min_bin)/diff_bin)));
if(interpolate)
{
f = (angle - (mini_b + bin*bin_size))/bin_size;
absf = fabs(f);
sf = sign(f);
nhd_bin = mymod(bin + sf , nori2);
R[i + indjm + bin*nynxnew] = mag*(1.0 - absf);
R[i + indjm + nhd_bin*nynxnew] = mag*absf;
}
else
{
R[i + indjm + bin*nynxnew] = mag;
}
m[i + indjm] = mag;
}
}
}
else
{
for(j = 0 ; j < nxnew ; j++)
{
indjx = pady + offyx - eyx - offye + (j + indtmpx)*nygradx;
indjy = pady + offyy - eyy - offye + (j + indtmpy)*nygrady;
indjm = j*nynew;
for(i = 0 ; i < nynew ; i++)
{
tempsx = gradx[i + indjx];
tempsy = grady[i + indjy];
angle = atan2(-tempsy , -(tempsx + verytiny));
mag = sqrt((tempsx*tempsx) + (tempsy*tempsy));
bin = min(nori2 , max(0 , (int)floor(nori*(angle - min_bin)/diff_bin)));
if(interpolate)
{
f = (angle - (mini_b + bin*bin_size))/bin_size;
absf = fabs(f);
sf = sign(f);
nhd_bin = mymod(bin + sf , nori2);
R[i + indjm + bin*nynxnew] = mag*(1.0 - absf);
R[i + indjm + nhd_bin*nynxnew] = mag*absf;
}
else
{
R[i + indjm + bin*nynxnew] = mag;
}
m[i + indjm] = mag;
}
}
}
/* L1 block-normalization via the Integral Image*/
for(i = 0 ; i < ny1nx1 ; i++)
{
sat[i] = 0.0;
}
for (j=1 ; j < nx1; j++)
{
indj = j*ny1;
index = indj - ny1;
indi = (j-1)*nynew;
for (i = 1 ; i < ny1 ; i++)
{
sat[i + indj] = sat[i-1 + indj] + sat[i + index] - sat[(i-1) + index] + m[(i-1) + indi];
}
}
for(l = 0 ; l < (nxnew/bx) ; l++)
{
x = l*bx;
for(p = 0 ; p < (nynew/by) ; p++)
{
y = p*by;
x1 = x + bx;
y1 = y + by;
temp = (sat[y1 + x1*ny1] - (sat[y1 + x*ny1] + sat[y + x1*ny1]) + sat[y + x*ny1]);
if(temp != 0.0)
{
temp = 1.0/temp;
}
else
{
temp = 1.0;
}
for (o = 0 ; o < nori ; o++)
{
index = o*nynxnew;
for(i = x ; i < x + bx ; i++)
{
indi = i*nynew + index;
for(j = y ; j < y + by ; j++)
{
R[j + indi] *= temp;
}
}
}
}
}
/*---- Orientation block definitions ---- */
index = 0;
for (p = 0 ; p < nspyr ; p++)
{
scaley = (spyr[p + nspyr*2]);
ly = (int) ( (1 - spyr[p + 0])/scaley + 1);
deltay = (int) (ny*scaley);
sy = (int) (ny*spyr[p + 0]);
offsety = max(0 , (int) ( floor(ny - ( (ly-1)*deltay + sy + 1)) ));
scalex = (spyr[p + nspyr*3]);
lx = (int) ( (1 - spyr[p + nspyr*1])/scalex + 1);
deltax = (int) (nx*scalex);
sx = (int) (nx*spyr[p + nspyr*1]);
offsetx = max(0 , (int) ( floor(nx - ( (lx-1)*deltax + sx + 1)) ));
ratio = maxfactor/(spyr[p + 0]*spyr[p + nspyr]);
for(l = 0 ; l < lx ; l++) /* Loop shift on x-axis */
{
origx = offsetx + l*deltax ;
for(q = 0 ; q < ly ; q++) /* Loop shift on y-axis */
{
origy = offsety + q*deltay ;
cell[0 + index] = origy + offye;
cell[1 + index] = origx + offxe;
cell[2 + index] = origy + sy;
cell[3 + index] = origx + sx;
cell[4 + index] = ratio;
index += 5;
}
}
}
/*---- Compute Oriented Edge Energy via the cumulated Integral Image over each orientations ---- */
for(i = 0 ; i < ny1nx1 ; i++)
{
sat[i] = 0.0;
}
for (o = 0 ; o < nori ; o++)
{
indexo = o*nynxnew;
for (j = 1 + offxe; j<nx1; j++)
{
indj = j*ny1;
index = indj - ny1;
indi = (j-1)*nynew;
for (i = 1 + offye ; i<ny1; i++)
{
sat[i + indj] = sat[i-1 + indj] + sat[i + index] - sat[(i-1) + index] + R[(i-1) + indi + indexo];
}
}
index = 0;
indexp = o*nH + vnorinH;
for (j=0 ; j < nH ; j++)
{
y0 = (int) cell[0 + index];
x0 = (int) cell[1 + index];
y1 = (int) cell[2 + index];
x1 = (int) cell[3 + index];
H[j + indexp] = (sat[y1 + x1*ny1] - (sat[y1 + x0*ny1] + sat[y0 + x1*ny1]) + sat[y0 + x0*ny1])*cell[4 + index];
index += 5;
}
}
/*---- Normalization ---- */
if(norm == 1) /* L1-norm */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += H[i];
}
temp = 1.0/(temp + tiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
}
}
}
if(norm == 2) /* L2-norm */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += (H[i]*H[i]);
}
temp = 1.0/sqrt(temp + verytiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
}
}
}
if(norm == 3) /* L1-sqrt */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += H[i];
}
temp = 1.0/(temp + tiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] = sqrt(H[i]*temp);
}
}
}
if(norm == 4) /* L2-clamped */
{
for(j = 0 ; j < nH ; j++)
{
indj = j*nori + vnorinH;
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += (H[i]*H[i]);
}
temp = 1.0/sqrt(temp + verytiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
if(H[i] > clamp)
{
H[i] = clamp;
}
}
temp = 0.0;
for(i = indj ; i < (nori+indj); i++)
{
temp += (H[i]*H[i]);
}
temp = 1.0/sqrt(temp + verytiny);
for(i = indj ; i < (nori+indj); i++)
{
H[i] *= temp;
}
}
}
}
free(Ipaded);
free(grady);
free(gradx);
free(R);
free(m);
free(sat);
free(cell);
}
