void divisores(int n)
{
mv.clear();
int a;
while(a!=n)
{
if(n%a == 0)
{
mv.push_back(a);
a++;
}
}
}
int Objectness::gtBndBoxSampling(const Vec4i &bbgt, vector<Vec4i> &samples, vecI &bbR)
{
double wVal = bbgt[2] - bbgt[0] + 1, hVal = (bbgt[3] - bbgt[1]) + 1;
wVal = log(wVal)/_logBase, hVal = log(hVal)/_logBase;
int wMin = max((int)(wVal - 0.5), _minT), wMax = min((int)(wVal + 1.5), _maxT);
int hMin = max((int)(hVal - 0.5), _minT), hMax = min((int)(hVal + 1.5), _maxT);
for (int h = hMin; h <= hMax; h++) for (int w = wMin; w <= wMax; w++) {
int wT = tLen(w) - 1, hT = tLen(h) - 1;
Vec4i bb(bbgt[0], bbgt[1], bbgt[0] + wT, bbgt[1] + hT);
if (DataSetVOC::interUnio(bb, bbgt) >= 0.5) {
samples.push_back(bb);
bbR.push_back(sz2idx(w, h));
//if (bbgt[3] > hT){
// bb = Vec4i(bbgt[0], bbgt[3] - hT, bbgt[0] + wT, bbgt[3]);
// CV_Assert(DataSetVOC::interUnio(bb, bbgt) >= 0.5);
// samples.push_back(bb);
// bbR.push_back(sz2idx(w, h));
//}
//if (bbgt[2] > wT){
// bb = Vec4i(bbgt[2] - wT, bbgt[1], bbgt[2], bbgt[1] + hT);
// CV_Assert(DataSetVOC::interUnio(bb, bbgt) >= 0.5);
// samples.push_back(bb);
// bbR.push_back(sz2idx(w, h));
//}
//if (bbgt[2] > wT && bbgt[3] > hT){
// bb = Vec4i(bbgt[2] - wT, bbgt[3] - hT, bbgt[2], bbgt[3]);
// CV_Assert(DataSetVOC::interUnio(bb, bbgt) >= 0.5);
// samples.push_back(bb);
// bbR.push_back(sz2idx(w, h));
//}
}
}
return samples.size();
}
// Training SVM with feature vector X and label Y.
// Each row of X is a feature vector, with corresponding label in Y.
// Return a CV_32F weight Mat
Mat Objectness::trainSVM(CMat &X1f, const vecI &Y, int sT, double C, double bias, double eps)
{
// Set SVM parameters
parameter param; {
param.solver_type = sT; // L2R_L2LOSS_SVC_DUAL;
param.C = C;
param.eps = eps; // see setting below
param.p = 0.1;
param.nr_weight = 0;
param.weight_label = NULL;
param.weight = NULL;
set_print_string_function(print_null);
CV_Assert(X1f.rows == Y.size() && X1f.type() == CV_32F);
}
// Initialize a problem
feature_node *x_space = NULL;
problem prob;{
prob.l = X1f.rows;
prob.bias = bias;
prob.y = Malloc(double, prob.l);
prob.x = Malloc(feature_node*, prob.l);
const int DIM_FEA = X1f.cols;
prob.n = DIM_FEA + (bias >= 0 ? 1 : 0);
x_space = Malloc(feature_node, (prob.n + 1) * prob.l);
int j = 0;
for (int i = 0; i < prob.l; i++){
prob.y[i] = Y[i];
prob.x[i] = &x_space[j];
const float* xData = X1f.ptr<float>(i);
for (int k = 0; k < DIM_FEA; k++){
x_space[j].index = k + 1;
x_space[j++].value = xData[k];
}
if (bias >= 0){
x_space[j].index = prob.n;
x_space[j++].value = bias;
}
x_space[j++].index = -1;
}
CV_Assert(j == (prob.n + 1) * prob.l);
}
// Training SVM for current problem
const char* error_msg = check_parameter(&prob, ¶m);
if(error_msg){
fprintf(stderr,"ERROR: %s\n",error_msg);
exit(1);
}
model *svmModel = train(&prob, ¶m);
Mat wMat(1, prob.n, CV_64F, svmModel->w);
wMat.convertTo(wMat, CV_32F);
free_and_destroy_model(&svmModel);
destroy_param(¶m);
free(prob.y);
free(prob.x);
free(x_space);
return wMat;
}
void DataSetVOC::loadBox(const FileNode &fn, vector<Vec4i> &boxes, vecI &clsIdx){
string isDifficult;
fn["difficult"]>>isDifficult;
if (isDifficult == "1")
return;
string strXmin, strYmin, strXmax, strYmax;
fn["bndbox"]["xmin"] >> strXmin;
fn["bndbox"]["ymin"] >> strYmin;
fn["bndbox"]["xmax"] >> strXmax;
fn["bndbox"]["ymax"] >> strYmax;
boxes.push_back(Vec4i(atoi(_S(strXmin)), atoi(_S(strYmin)), atoi(_S(strXmax)), atoi(_S(strYmax))));
string clsName;
fn["name"]>>clsName;
clsIdx.push_back(findFromList(clsName, classNames));
CV_Assert_(clsIdx[clsIdx.size() - 1] >= 0, ("Invalidate class name\n"));
}
bool isLucky(vecI mv){
int cont;
int n = mv.size();
for(int i = 0; i < n; i++)
{
if(mv[i]== 4 or mv[i] == 7)
cont++;
}
if(cont == n) return true;
else return false;
}
int CmAPCluster::ReMapIdx(vecI &mapIdx)
{
int N = (int)mapIdx.size(), newCount = 0;
map<int, int> idxCount, oldNewIdx;
vecI newIdx(N);
for (int i = 0; i < N; i++){
if (idxCount.find(mapIdx[i]) == idxCount.end())
oldNewIdx[mapIdx[i]] = newCount++, idxCount[mapIdx[i]]++;
mapIdx[i] = oldNewIdx[mapIdx[i]];
}
return (int)idxCount.size();
}
void Objectness::predictBBoxSI(CMat &img3u, ValStructVec<float, Vec4i> &valBoxes, vecI &sz, int NUM_WIN_PSZ, bool fast)
{
const int numSz = _svmSzIdxs.size();
const int imgW = img3u.cols, imgH = img3u.rows;
valBoxes.reserve(10000);
sz.clear();
sz.reserve(10000);
for (int ir = numSz - 1; ir >= 0; ir--) {
int r = _svmSzIdxs[ir];
int height = cvRound(pow(_base, r/_numT + _minT)), width = cvRound(pow(_base, r%_numT + _minT));
if (height > imgH * _base || width > imgW * _base)
continue;
height = min(height, imgH), width = min(width, imgW);
Mat im3u, matchCost1f, mag1u;
resize(img3u, im3u, Size(cvRound(_W*imgW*1.0/width), cvRound(_W*imgH*1.0/height)));
gradientMag(im3u, mag1u);
matchCost1f = _tigF.matchTemplate(mag1u);
ValStructVec<float, Point> matchCost;
nonMaxSup(matchCost1f, matchCost, _NSS, NUM_WIN_PSZ, fast);
// Find true locations and match values
double ratioX = width/_W, ratioY = height/_W;
int iMax = min(matchCost.size(), NUM_WIN_PSZ);
for (int i = 0; i < iMax; i++) {
float mVal = matchCost(i);
Point pnt = matchCost[i];
Vec4i box(cvRound(pnt.x * ratioX), cvRound(pnt.y*ratioY));
box[2] = cvRound(min(box[0] + width, imgW));
box[3] = cvRound(min(box[1] + height, imgH));
box[0] ++;
box[1] ++;
valBoxes.pushBack(mVal, box);
sz.push_back(ir);
}
}
//exit(0);
}
bool DataSetVOC::loadBBoxes(CStr &nameNE, vector<Vec4i> &boxes, vecI &clsIdx)
{
string fName = format(_S(annoPathW), _S(nameNE));
FileStorage fs(fName, FileStorage::READ);
FileNode fn = fs["annotation"]["object"];
boxes.clear();
clsIdx.clear();
if (fn.isSeq()){
for (FileNodeIterator it = fn.begin(), it_end = fn.end(); it != it_end; it++)
loadBox(*it, boxes, clsIdx);
}
else
loadBox(fn, boxes, clsIdx);
return true;
}
// src3f are BGR, color3f are 1xBinDim matrix represent color fore each histogram bin
int CmColorQua::S_BinInf(CMat& idx1i, Mat &color3f, vecI &colorNum, int method, CMat &src3f)
{
int totalBinNum = 0;
CV_Assert(idx1i.data != NULL && idx1i.type() == CV_32S && method >= 0 && method < S_Q_NUM);
// Find colors for each bin
color3f = Mat::zeros(1, binNum[method], CV_32FC3);
Vec3f* color = (Vec3f*)(color3f.data);
vector<Vec3d> colorD(color3f.cols, 0);
colorNum.resize(color3f.cols, 0);
if (src3f.size() != Size() && src3f.data != NULL) {
for (int r = 0; r < idx1i.rows; r++) {
const int *idx = idx1i.ptr<int>(r);
const Vec3f *src = src3f.ptr<Vec3f>(r);
for (int c = 0; c < idx1i.cols; c++) {
colorD[idx[c]] += src[c];
colorNum[idx[c]] ++;
}
}
}
S_RECOVER_FUNC SR_Function = srFuns[method];
for (int i = 0; i < color3f.cols; i++) {
if (colorNum[i] == 0)
(*SR_Function)(i, color[i]);
else
totalBinNum += colorNum[i];
}
if (method == 1)
cvtColor(color3f, color3f, CV_HSV2BGR);
else if (method == 2)
cvtColor(color3f, color3f, CV_Lab2BGR);
for (int i = 0; i < color3f.cols; i++)
if (colorNum[i] > 0)
color[i] = Vec3f((float)(colorD[i][0]/colorNum[i]), (float)(colorD[i][1]/colorNum[i]), (float)(colorD[i][2]/colorNum[i]));
return totalBinNum;
}
void CBuild::MergeLM()
{
vecDefl Layer;
vecDefl deflNew;
vecDefl SEL;
Status("Processing...");
for (u32 light_layer=0; light_layer<pBuild->lights.size(); light_layer++)
{
// Select all deflectors, which contain this light-layer
Layer.clear ();
b_light* L_base = pBuild->lights[light_layer].original;
for (int it=0; it<(int)g_deflectors.size(); it++)
{
if (g_deflectors[it].bMerged) continue;
if (0==g_deflectors[it].GetLayer(L_base)) continue;
Layer.push_back (g_deflectors[it]);
}
if (Layer.empty()) continue;
// Resort layer
// Merge this layer
while (Layer.size())
{
// Sort layer (by material and distance from "base" deflector)
Deflector = Layer[0];
std::sort (Layer.begin()+1,Layer.end(),cmp_defl);
// Select first deflectors which can fit
int maxarea = lmap_size*lmap_size*6; // Max up to 6 lm selected
int curarea = 0;
for (it=1; it<(int)Layer.size(); it++)
{
int defl_area = Layer[it]->GetLayer(L_base)->Area();
if (curarea + defl_area > maxarea) break;
curarea += defl_area;
SEL.push_back(Layer[it]);
}
if (SEL.empty())
{
// No deflectors found to merge
// Simply transfer base deflector to _new list
deflNew.push_back(Deflector);
g_deflectors.erase(g_deflectors.begin());
} else {
// Transfer rects
SEL.push_back(Deflector);
for (int K=0; K<(int)SEL.size(); K++)
{
_rect T;
T.a.set (0,0);
T.b.set (SEL[K]->lm.dwWidth+2*BORDER-1, SEL[K]->lm.dwHeight+2*BORDER-1);
T.iArea = SEL[K]->iArea;
selected.push_back (T);
perturb.push_back (K);
}
// Sort by size decreasing and startup
std::sort (perturb.begin(),perturb.end(),cmp_rect);
InitSurface ();
int id = perturb[0];
_rect &First = selected[id];
_rect_register (First,SEL[id],FALSE);
best.push_back (First);
best_seq.push_back (id);
brect.set (First);
// Process
collected.reserve (SEL.size());
for (int R=1; R<(int)selected.size(); R++)
{
int ID = perturb[R];
if (_rect_place(selected[ID],SEL[ID]))
{
brect.Merge (collected.back());
best.push_back (collected.back());
best_seq.push_back (ID);
}
Progress(float(R)/float(selected.size()));
}
R_ASSERT (brect.a.x==0 && brect.a.y==0);
// Analyze resuls
clMsg("%3d / %3d - [%d,%d]",best.size(),selected.size(),brect.SizeX(),brect.SizeY());
CDeflector* pDEFL = new CDeflector();
pDEFL->lm.bHasAlpha = FALSE;
pDEFL->lm.dwWidth = lmap_size;
pDEFL->lm.dwHeight = lmap_size;
for (K = 0; K<(int)best.size(); K++)
{
int iRealIndex = best_seq [K];
_rect& Place = best [K];
_point& Offset = Place.a;
BOOL bRotated;
b_texture& T = SEL[iRealIndex]->lm;
int T_W = (int)T.dwWidth + 2*BORDER;
int T_H = (int)T.dwHeight + 2*BORDER;
if (Place.SizeX() == T_W) {
R_ASSERT(Place.SizeY() == T_H);
bRotated = FALSE;
} else {
R_ASSERT(Place.SizeX() == T_H);
R_ASSERT(Place.SizeY() == T_W);
bRotated = TRUE;
}
// Merge
pDEFL->Capture (SEL[iRealIndex],Offset.x,Offset.y,Place.SizeX(),Place.SizeY(),bRotated);
// Destroy old deflector
vecDeflIt OLD = std::find(g_deflectors.begin(),g_deflectors.end(),SEL[iRealIndex]);
VERIFY (OLD!=g_deflectors.end());
g_deflectors.erase(OLD);
xr_delete (SEL[iRealIndex]);
}
pDEFL->Save ();
deflNew.push_back (pDEFL);
// Cleanup
SEL.clear ();
collected.clear ();
selected.clear ();
perturb.clear ();
best.clear ();
best_seq.clear ();
brect.iArea = INT_MAX;
}
Progress(1.f-float(g_deflectors.size())/float(dwOldCount));
}
}
R_ASSERT(g_deflectors.empty());
g_deflectors = deflNew;
clMsg ("%d lightmaps builded",g_deflectors.size());
}