void AnalyzeInput::evaltrajs(vector<Trajectory*> &trajs){
//******Calculate Cost, Acceleration, and Distance traveled per time step*******************************
Cost evalcost;
this->DR = 0;
this->C = 0;
for (int i = 0; i < trajs.size(); i++){
trajs[i]->R = 0;
trajs[i]->C = 0;
double Cmin = 100;
double Cmax = 0;
double Rmin = 1E9;
double Rmax = 0;
for (int j = 0; j < trajs[i]->particles.size()-1; j++){
Particle* P = trajs[i]->particles[j];
Particle* Pn = trajs[i]->particles[j+1];
P->dr = distance(P,Pn);
if(P->dr > Rmax)
Rmax = P->dr;
if(P->dr < Rmin)
Rmin = P->dr;
trajs[i]->R += P->dr;
Pn->vel = P->dr * FRAMESPERSEC;
if (j>1){
Particle* Pm = trajs[i]->particles[j-1];
P->accel = abs(Pn->vel - Pm->vel) * FRAMESPERSEC/2.0;
}
if (j >= COST_TRAJ_SIZE - 1){
int s = (j) - (COST_TRAJ_SIZE -1);
Trajectory tr;
for (int x = s; x <= j; x++){
tr.particles.push_back(trajs[i]->particles[x]);
}
Pn->cost = evalcost.cost(&tr, Pn);
}else{
Pn->cost = 0.0;
}
if(Pn->cost > Cmax)
Cmax = Pn->cost;
if(Pn->cost < Cmin && Pn->cost != 0)
Cmin = Pn->cost;
trajs[i]->C += Pn->cost;
}
trajs[i]->Cl = Cmin;
trajs[i]->Ch = Cmax;
trajs[i]->C = trajs[i]->C / ((double) trajs[i]->particles.size());
this->C += trajs[i]->C;
trajs[i]->Rl = Rmin;
trajs[i]->Rh = Rmax;
trajs[i]->R = trajs[i]->R / ((double) trajs[i]->particles.size());
this->DR += trajs[i]->R;
}
this->C = this->C / trajs.size();
this->DR = this->DR / trajs.size();
}
std::vector<std::pair<std::vector<uint>, std::vector<SentenceInfo> aStar::Suchalgorithmus(char* eingabe, PTree<PTree <Cost> >* blacktree, Lexicon* eLex, Lexicon* fLex){
igzstream in(eingabe);
aStar::flex=fLex;
elex=eLex;
schwarz=blacktree;
string token,line;
unsigned int lineNumber = 0;
while(getline(in,line)){
istringstream ist(line); //Einlesen des Satzes
vector<unsigned int> sentence_id;
vector<HypothesisNode> Knoten;
Knoten.push_back(HypothesisNode());//initialisiert den ersten Knoten
Cost startkosten(0);
Knoten[0].setBestcost(startkosten);
//cout << "start kosten " << Knoten[0].getBestcost().cost() << endl;
int aktPos=0; //merkt sich, wieviele Wörter schon eingelesen wurden
while ( ist >> token){
Word word_id_french=flex->getWord_or_add(token); // das word zum Wort (mit 2 Bits Sprache)
unsigned int id_french= word_id_french.wordId(); //die id ohne sprachbits
sentence_id.push_back(id_french);
aktPos++;
HypothesisNode knoten_next= HypothesisNode();//initialisiert den nächsten Knoten mit den bisherigen Kosten
for (int laengePhrase=1; laengePhrase<5; laengePhrase++){
int posPhraseStart=aktPos-laengePhrase; //gibt die Pos. für den Knoten, auf dem die Phrase beginnt
if (posPhraseStart < 0) break; //wir befinden uns am Satzanfang und es gibt keine Phrasen
vector<unsigned int> fphrase;
for (int i=posPhraseStart; i<aktPos; i++){
fphrase.push_back(sentence_id[i]);
}
PTree<PTree <Cost> >* schwarzRest=schwarz->traverse(fphrase);
if (!schwarzRest) continue; //wenn es die französische Phrase nicht gibt, nächste überprüfen
PTree <Cost>* blauBaum=&schwarzRest->c;
if (blauBaum){
int counter=0; //nur fürs Programmieren, damit alle Fehler ausgemerzt werden
for (PTree<Cost>::iterator it=blauBaum->begin(); it!=blauBaum->end(); it++){
//if (counter++==10) continue;
vector<unsigned int> ephrase=it->phrase();
Cost relfreq = it->c;
if (relfreq.cost() == 1./0. ) continue;
double cost_till_aktPos=Knoten[posPhraseStart].getBestcost().cost();
if (cost_till_aktPos+prune > knoten_next.getBestcost().cost()) continue; //pruning ergibt, das ist eine schlecht Übersetzung
if(cost_till_aktPos+relfreq.cost() < knoten_next.getBestcost().cost()) knoten_next.setBestcost(Knoten[posPhraseStart].getBestcost()+relfreq.cost());
PartialTranslation* Kante= new PartialTranslation(relfreq,ephrase,&knoten_next,posPhraseStart);
Knoten[posPhraseStart].add_PartialTranslation_to_Inbound(Kante);
knoten_next.add_PartialTranslation_to_Outbound(Kante);
}
}
}
if (knoten_next.getOutbound().size() == 0){
//zuerst in das englische Lexicon einfügen
string word_string = flex->getString(sentence_id[aktPos-1]);
unsigned int id_english=elex->getWord_or_add(word_string);
//dann die Kante anlegen, dabei sollen die Kosten niedrig sein, da sie sowieso genutzt werden muss, kann sie auch direkt exploriert werden
PartialTranslation* Kante= new PartialTranslation(Cost(0),vector<unsigned int>{id_english},&Knoten[aktPos],aktPos-1);
knoten_next.setBestcost(Knoten.back().getBestcost());
knoten_next.add_PartialTranslation_to_Outbound(Kante);
Knoten.back().add_PartialTranslation_to_Inbound(Kante);
}
Knoten.push_back(knoten_next); //letzter Knoten (node_next) hat keine eingehenden Kanten
}
//dotGraph(Knoten, elex);
aStar astar(Knoten);
astar.lineNumber = lineNumber;
std::vector<SentenceInfo> sentenceInfos = astar.print(astar.search(), sentence_id, schwarz);
for(unsigned int i = 0; i < Knoten.size(); i++){
HypothesisNode& hnode = Knoten[i];
for(unsigned int j = 0; j < hnode.getOutbound().size(); j++)
delete hnode.getOutbound()[j];
}
std::pair<std::vector<uint>, std::vector<SentenceInfo> > pair_tmp;
pair_tmp.first = sentence_id;
pair_tmp.second = sentenceInfos;
nBestLists.push_back(pair_tmp);
lineNumber ++;
}
return nBestLists;
}