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();
}
void divisores(int n)
{
mv.clear();
int a;
while(a!=n)
{
if(n%a == 0)
{
mv.push_back(a);
a++;
}
}
}
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"));
}
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);
}
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());
}
