u_int32_t ORBFeatureExtractor::processNewImage(unsigned i_imageId, unsigned i_imgSize,
char *p_imgData)
{
Mat img;
u_int32_t i_ret = ImageLoader::loadImage(i_imgSize, p_imgData, img);
if (i_ret != OK)
return i_ret;
vector<KeyPoint> keypoints;
Mat descriptors;
ORB(1000, 1.02, 100)(img, noArray(), keypoints, descriptors);
unsigned i_nbKeyPoints = 0;
list<HitForward> imageHits;
unordered_set<u_int32_t> matchedWords;
for (unsigned i = 0; i < keypoints.size(); ++i)
{
i_nbKeyPoints++;
// Recording the angle on 16 bits.
u_int16_t angle = keypoints[i].angle / 360 * (1 << 16);
u_int16_t x = keypoints[i].pt.x;
u_int16_t y = keypoints[i].pt.y;
vector<int> indices(1);
vector<int> dists(1);
wordIndex->knnSearch(descriptors.row(i), indices, dists, 1);
for (unsigned j = 0; j < indices.size(); ++j)
{
const unsigned i_wordId = indices[j];
if (matchedWords.find(i_wordId) == matchedWords.end())
{
HitForward newHit;
newHit.i_wordId = i_wordId;
newHit.i_imageId = i_imageId;
newHit.i_angle = angle;
newHit.x = x;
newHit.y = y;
imageHits.push_back(newHit);
matchedWords.insert(i_wordId);
}
}
}
#if 0
// Draw keypoints.
Mat img_res;
drawKeypoints(img, keypoints, img_res, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
// Show the image.
imshow("Keypoints 1", img_res);
waitKey();
#endif
// Record the hits.
return index->addImage(i_imageId, imageHits);
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
numFoto=0;
cap = new VideoCapture(1);
if(!cap->isOpened())
cap = new VideoCapture(1);
capture = true;
showColorImage = false;
winSelected = false;
cap->set(CV_CAP_PROP_FRAME_WIDTH, 320);
cap->set(CV_CAP_PROP_FRAME_HEIGHT, 240);
imgS = new QImage(320,240, QImage::Format_RGB888);
visorS = new RCDraw(320,240, imgS, ui->imageFrameS);
imgD = new QImage(320,240, QImage::Format_RGB888);
visorD = new RCDraw(320,240, imgD, ui->imageFrameD);
colorImage.create(240,320,CV_8UC3);
grayImage.create(240,320,CV_8UC1);
destColorImage.create(240,320,CV_8UC3);
Black_Color_Image.create(240,320,CV_8UC3);
Black_Gray_Image.create(240,320,CV_8UC1);
destGrayImage.create(240,320,CV_8UC1);
gray2ColorImage.create(240,320,CV_8UC3);
destGray2ColorImage.create(240,320,CV_8UC3);
connect(&timer,SIGNAL(timeout()),this,SLOT(compute()));
connect(ui->captureButton,SIGNAL(clicked(bool)),this,SLOT(start_stop_capture(bool)));
connect(ui->colorButton,SIGNAL(clicked(bool)),this,SLOT(change_color_gray(bool)));
connect(ui->AddObjIma,SIGNAL(clicked()),this,SLOT(set_Image()));
connect(ui->DelObjIma,SIGNAL(clicked()),this,SLOT(deleteImageInSet()));
connect(ui->horizontalSlider,SIGNAL(valueChanged(int)),this,SLOT(changeImage()));
connect(ui->SelectComboBox,SIGNAL(currentIndexChanged(int)),this,SLOT(changeImage()));
connect(visorS,SIGNAL(windowSelected(QPointF, int, int)),this,SLOT(selectWindow(QPointF, int, int)));
connect(visorS,SIGNAL(pressEvent()),this,SLOT(deselectWindow()));
ListaObjetosImagenes.resize(3);
listaDescriptores.resize(3);
ListaPuntosImagenes.resize(3);
NombresObjetos.resize(3);
NombresObjetos[0]="Objeto 1";
NombresObjetos[1]="Objeto 2";
NombresObjetos[2]="Objeto 3";
LpFinal.resize(3);
listaContadores.insert(listaContadores.begin(),3,0);
Colores.resize(5);
Colores[0]=Qt::red;
Colores[1]=Qt::yellow;
Colores[2]=Qt::blue;
Colores[3]=Qt::green;
Colores[4]=Qt::red+Qt::yellow;
orb=ORB();
bfm=BFMatcher(NORM_HAMMING,false);
MaxDistance=50.0;
timer.start(60);
//------------------AMPLIACIONES-------------------
LpFinalAmpliacion.resize(3);
}
void MO_matrix_standard::init() {
moCoeff.Resize(nmo, totbasis);
single_write(cout, "Standard MO\n");
ifstream ORB(orbfile.c_str());
if(!ORB)
{
error("couldn't find orb file ", orbfile);
}
single_write(cout,"Reading orbitals from ",orbfile, "\n");
Array3 <int> coeffmat;
Array1 <doublevar> coeff;
int tempint=readorb(ORB,centers,nmo, maxbasis,kpoint, coeffmat, coeff);
ORB.close();
single_write(cout, tempint," unique MO coefficients found.\n\n");
//Fill moCoeff
int totfunc=0;
for(int ion=0; ion<centers.size(); ion++)
{
int f=0;
doublevar dot=0;
for(int d=0; d<3; d++) dot+=centers.centers_displacement(ion,d)*kpoint(d);
cout << "kptfac " << cos(dot*pi) << " displacement "
<< centers.centers_displacement(ion,0) << " "
<< endl;
doublevar kptfac=cos(dot*pi);
for(int n=0; n< centers.nbasis(ion); n++)
{
//evaluate atomic orbital
int fnum=centers.basis(ion,n);
int imax=basis(fnum)->nfunc();
for(int i=0; i<imax; i++)
{ //sum over the symmetries
for(int mo=0; mo<nmo; mo++)
{ //and the MO's
//cout << "ion " << ion;
//cout << " i " << i << " mo " << mo << " fnum " << fnum << endl;
//cout << "coeffmat " << coeffmat(mo,ion, f) << endl;
//moCoeff(ion, f, mo)=coeff(coeffmat(mo,ion,f));
if(coeffmat(mo,ion, f) == -1) {
cout << "missing MO pointer: mo# " << mo << " ion # " << ion
<< " function on ion: " << f << endl;
error("In the orb file, there is a missing pointer. It might "
"be a badly structured file.");
}
doublevar temp=coeff(coeffmat(mo,ion,f));
moCoeff(mo, totfunc)=magnification_factor*kptfac*temp;
}//mo
f++; //keep a total of functions on center
totfunc++;
} //i
} //n
} //ion
}
void MO_matrix_blas::init() {
//mo_counter.Resize(nmo);
//mo_counter=0.0;
//n_calls=0;
//Determine where to cut off the basis functions
cutoff.Resize(totbasis);
int basiscounter=0;
for(int i=0; i< centers.size(); i++)
{
for(int j=0; j< centers.nbasis(i); j++)
{
Basis_function* tempbasis=basis(centers.basis(i,j));
for(int n=0; n< tempbasis->nfunc(); n++)
{
//cout << "cutoff " << endl;
cutoff(basiscounter)=tempbasis->cutoff(n);
//cout << "rcut(" << basiscounter << ") "
// << cutoff(basiscounter) << endl;
basiscounter++;
}
}
}
obj_cutoff.Resize(basis.GetDim(0));
for(int b=0; b< basis.GetDim(0); b++) {
int nf=basis(b)->nfunc();
doublevar maxcut=basis(b)->cutoff(0);
for(int n=1; n< nf; n++) {
doublevar cut=basis(b)->cutoff(n);
if(cut > maxcut) maxcut=cut;
}
obj_cutoff(b)=maxcut;
}
nfunctions.Resize(basis.GetDim(0));
for(int b=0; b< basis.GetDim(0); b++) {
nfunctions(b)=basis(b)->nfunc();
}
moCoeff.Resize(totbasis, nmo);
ifstream ORB(orbfile.c_str());
if(!ORB) error("couldn't find orb file ", orbfile);
Array3 <int> coeffmat;
Array1 <doublevar> coeff;
readorb(ORB,centers, nmo, maxbasis, kpoint,coeffmat, coeff);
string in;
ORB.close();
//Find the cutoffs
int totfunc=0;
for(int ion=0; ion<centers.size(); ion++) {
int f=0;
doublevar dot=0;
for(int d=0; d<3; d++) dot+=centers.centers_displacement(ion,d)*kpoint(d);
//cout << "kptfac " << cos(dot*pi) << " displacement "
// << centers.centers_displacement(ion,0) << " "
// << endl;
doublevar kptfac=cos(dot*pi);
for(int n=0; n< centers.nbasis(ion); n++) {
int fnum=centers.basis(ion,n);
int imax=basis(fnum)->nfunc();
for(int i=0; i<imax; i++){
for(int mo=0; mo<nmo; mo++) {
if(coeffmat(mo,ion, f) == -1) {
moCoeff(totfunc,mo)=0.0;
//cout << "missing MO pointer: mo# " << mo << " ion # " << ion
//<< " function on ion: " << f << endl;
//error("In the orb file, there is a missing pointer. It might "
// "be a badly structured file.");
}
else moCoeff(totfunc, mo)=magnification_factor*kptfac*coeff(coeffmat(mo,ion,f));
}//mo
f++; //keep a total of functions on center
totfunc++;
} //i
} //n
} //ion
//output_array(moCoeff);
}
void OrbDescriptorExtractor::read(const cv::FileNode& fn)
{
params_.read(fn);
orb_ = ORB(0, params_);
}
/** Default constructor */
OrbDescriptorExtractor::OrbDescriptorExtractor(ORB::CommonParams params) :
params_(params)
{
orb_ = ORB(0, params);
}
/**
* @brief Processed a search request.
* @param request the request to proceed.
*/
u_int32_t ORBSearcher::searchImage(SearchRequest &request)
{
timeval t[5];
gettimeofday(&t[0], NULL);
cout << "Loading the image and extracting the ORBs." << endl;
Mat img;
u_int32_t i_ret = ImageLoader::loadImage(request.imageData.size(),
request.imageData.data(), img);
if (i_ret != OK)
return i_ret;
vector<KeyPoint> keypoints;
Mat descriptors;
ORB(1000, 1.02, 100)(img, noArray(), keypoints, descriptors);
gettimeofday(&t[1], NULL);
cout << "time: " << getTimeDiff(t[0], t[1]) << " ms." << endl;
cout << "Looking for the visual words. " << endl;
unordered_map<u_int32_t, list<Hit> > imageReqHits; // key: visual word, value: the found angles
for (unsigned i = 0; i < keypoints.size(); ++i)
{
#define NB_NEIGHBORS 1
vector<int> indices(NB_NEIGHBORS);
vector<int> dists(NB_NEIGHBORS);
wordIndex->knnSearch(descriptors.row(i), indices,
dists, NB_NEIGHBORS);
for (unsigned j = 0; j < indices.size(); ++j)
{
const unsigned i_wordId = indices[j];
if (imageReqHits.find(i_wordId) == imageReqHits.end())
{
// Convert the angle to a 16 bit integer.
Hit hit;
hit.i_imageId = 0;
hit.i_angle = keypoints[i].angle / 360 * (1 << 16);
hit.x = keypoints[i].pt.x;
hit.y = keypoints[i].pt.y;
imageReqHits[i_wordId].push_back(hit);
}
}
}
cout << imageReqHits.size() << " visual words kept for the request." << endl;
const unsigned i_nbTotalIndexedImages = index->getTotalNbIndexedImages();
cout << i_nbTotalIndexedImages << " images indexed in the index." << endl;
unordered_map<u_int32_t, vector<Hit> > indexHits; // key: visual word id, values: index hits.
index->getImagesWithVisualWords(imageReqHits, indexHits);
gettimeofday(&t[2], NULL);
cout << "time: " << getTimeDiff(t[1], t[2]) << " ms." << endl;
cout << "Ranking the images." << endl;
unordered_map<u_int32_t, float> weights; // key: image id, value: image score.
for (unordered_map<u_int32_t, vector<Hit> >::const_iterator it = indexHits.begin();
it != indexHits.end(); ++it)
{
const vector<Hit> &hits = it->second;
const float f_weight = log((float)i_nbTotalIndexedImages / hits.size());
for (vector<Hit>::const_iterator it2 = hits.begin();
it2 != hits.end(); ++it2)
{
/* TF-IDF according to the paper "Video Google:
* A Text Retrieval Approach to Object Matching in Videos" */
unsigned i_totalNbWords = index->countTotalNbWord(it2->i_imageId);
weights[it2->i_imageId] += f_weight / i_totalNbWords;
}
}
priority_queue<SearchResult> rankedResults;
for (tr1::unordered_map<unsigned, float>::const_iterator it = weights.begin();
it != weights.end(); ++it)
rankedResults.push(SearchResult(it->second, it->first));
gettimeofday(&t[3], NULL);
cout << "time: " << getTimeDiff(t[2], t[3]) << " ms." << endl;
cout << "Reranking 300 among " << rankedResults.size() << " images." << endl;
priority_queue<SearchResult> rerankedResults;
reranker.rerank(imageReqHits, indexHits,
rankedResults, rerankedResults, 300);
gettimeofday(&t[4], NULL);
cout << "time: " << getTimeDiff(t[3], t[4]) << " ms." << endl;
cout << "Returning the results. " << endl;
returnResults(rerankedResults, request, 100);
#if 0
// Draw keypoints and ellipses.
Mat img_res;
drawKeypoints(img, cleanKeypoints, img_res, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
for (unsigned i = 0; i < ellipses.size(); ++i)
ellipse( img_res, ellipses[i], Scalar(0, 0, 255), 1);
// Show the image.
imshow("Keypoints 1", img_res);
#endif
return SEARCH_RESULTS;
}