zeitverlauf.cpp

gehe zur Dokumentation dieser Datei

// zeitverlauf.cpp
// LFTVideo.cpp  v1.7
//               12.5.2003
// 
// für weitere Informationen:
// siehe header von main.cpp

#include "zeitverlauf.h"

#include <qfile.h>
#include <qtextstream.h>
#include <math.h>                       // für floor

// class MinSec

MinSec::MinSec (int mins, double secs, long milliseconds) {
        double allesInSekunden= mins*60 + secs + (double) milliseconds/1000;
        Min=allesInSekunden / 60;

        Sec=((int) allesInSekunden) % 60 ;
        Sec += nachkomma(allesInSekunden);
};

double MinSec::toSecs() const{
        return mins()*60+secs();
};

double MinSec::secsTo(const MinSec &rhs) const{
        return rhs.toSecs() - this->toSecs();
};

MinSec MinSec::addSecs (double s) const{
        return MinSec(0, this->toSecs()+s); 
};

bool operator ==(const MinSec& x, const MinSec& y){
        return x.toSecs() == y.toSecs(); 
}

bool operator <(const MinSec& x, const MinSec& y){
        return x.toSecs() < y.toSecs(); 
};

MinSec operator -(const MinSec& x, const MinSec& y){
        return MinSec(0, y.secsTo(x));
}

/*
// alt:
double operator -(const MinSec& x, const MinSec& y){
        qDebug ("verwendet: double operator -(const MinSec& x, const MinSec& y)");
        // Konsequenter ist ein Ergebnistyp MinSec
        //       der dann evtl. anschliessend erst per toSecs 
        //       in double umgewandelt wird. Siehe oben.

        double xx=x.toSecs();
        double yy=y.toSecs();
        return xx-yy;
}
*/

struct MinSec::less : public binary_function<MinSec, MinSec, bool>{
        bool operator()(const MinSec& x, const MinSec& y) const{
                        return x < y; };
};

// helper: führende Null ausgeben, wenn 0123456789
QString leadingZero(int n){
        QString temp="";
        if (n<10 && n>=0) temp+="0";
        temp+="%1"; 
        temp=temp.arg(n);
        return temp;
};

// helper: führende Null ausgeben, wenn <100, zwei Nullen, wenn 0123456789
QString leading2Zeros(int n){
        QString temp="";
        if (n<100 && n>=0) temp+="0";
        temp+="%1"; 
        temp=temp.arg(leadingZero(n));
        return temp;
};

// helper: nur die Nachkommastellen zurückgeben, immer positiv
double nachkomma (double zahl){
        return fabs(zahl-(long)zahl);
}

// helper: abrunden wenn < .5, aufrunden, wenn >= .5
double runden (double zahl){
        return floor(zahl + 0.5);
}


QString MinSec::toQString() const{
        QString temp=leadingZero(mins())+":"+leadingZero(secs());
        temp+="."+leading2Zeros(millisecs());
        return temp;
};

bool MinSec::liesVonTextStream(QTextStream &s){
        
        QString in;
        s >> in;
        int minutes; double seconds;
        int Doppelpunkt;
        Doppelpunkt=in.find(":");
        if (Doppelpunkt<=0) return false;

        bool OK1,OK2;
        OK1=true;OK2=true;
        minutes=in.left(Doppelpunkt).toInt(&OK1);

        // qDebug (in.right(in.length()-Doppelpunkt-1));
        seconds=in.right(in.length()-Doppelpunkt-1).toDouble(&OK2);
        
        *this=MinSec(minutes, seconds);
        return OK1 && OK2;
}
        
void MinSec::testFloorInt(){
        qDebug("\ntestFloorInt");
        double a=123.456;
        double b=-123.456;
        qDebug("floor(...): %f", floor(a)); 
        qDebug("(int)...: %d", (int)a);
        qDebug("floor(...): %f", floor(b));
        qDebug("(int)...: %d", (int)b);
        qDebug("positiv: zahl - (int)zahl...: %f", a-(int)a);
        qDebug("negativ: zahl - (int)zahl...: %f", b-(int)b);
        qDebug("negativ: fmod(zahl,1)...: %f", fmod(b,1));
        qDebug("positiv: nachkomma(zahl)...: %f", nachkomma(a));
        qDebug("negativ: nachkomma(zahl)...: %f", nachkomma(b));
        a=1.5; b=-1.5;
        qDebug("runden(%f) = %d", a, runden(a));
        qDebug("runden(%f) = %d", b, runden(b));
        a=1.4999; b=-1.4999;
        qDebug("runden(%f) = %d", a, runden(a));
        qDebug("runden(%f) = %d", b, runden(b));

        qDebug("\n");
};


void MinSec::testMinSec(){
        qDebug("\ntestMinSec");
        MinSec ms(1,12);
        qDebug("%f", ms.toSecs());
        qDebug(ms.toQString());
        MinSec ms2(2,13.05);
        qDebug(ms2.toQString());
        qDebug("%f\n", ms.secsTo(ms2));

        ms=MinSec (1,12,0);
        qDebug("%f", ms.toSecs());
        qDebug(ms.toQString());
        ms2=MinSec (2,13,50);
        qDebug(ms2.toQString());
        qDebug("%f\n", ms.secsTo(ms2));

        QString testdata="12:34.567";
        MinSec liesZeitEin;
        liesZeitEin.liesVonTextStream( QTextIStream(&testdata) );
        qDebug(liesZeitEin.toQString() );

        QString testdata2="2:4.6";
        liesZeitEin.liesVonTextStream( QTextIStream(&testdata2) );
        qDebug(liesZeitEin.toQString() );

        qDebug("In mm, ss, ttt zerlegt: %d, %f, %d", 
                liesZeitEin.mins(), liesZeitEin.secs(), liesZeitEin.millisecs());

        qDebug("\n");
}


// struct IntervallErgebnis

QString IntervallErgebnis::toQString() const{
        QString temp="";
        temp+="%1\t%2\t%3";
        temp=temp.arg(Einschaetzung).arg(EinschaetzungDavor).arg(Dauer);
        return temp;
}

ostream& operator<< (ostream& os, const IntervallErgebnis& rhs){
        os << rhs.toQString().latin1();
        return os;
}

// class RatingVerlauf

RatingVerlauf::RatingVerlauf () {
        // Konstruktor mit 00:00.000 und null Rating
        Sinneinheiten.insert(MinSec2Rating::value_type(MinSec(0,0,0),null));
};

RatingVerlauf::~RatingVerlauf () {
        Sinneinheiten.clear();
};

void RatingVerlauf::RatingLoeschen(const MinSec &Endmoment){
        Sinneinheiten.erase(Endmoment);
}

void RatingVerlauf::RatingAnhaengen(const MinSec &Endmoment, 
                                                                        const RatingSkala Einschaetzung){
        Sinneinheiten.insert(MinSec2Rating::value_type(Endmoment,Einschaetzung));
}

MinSec RatingVerlauf::BisherLetzterMoment(){
        MinSec2Rating::iterator it=Sinneinheiten.end();
        it--;
        return it->first;
}

IntervallErgebnis RatingVerlauf::RatingAuslesen (const MinSec &Endmoment){
        IntervallErgebnis temp(error, error,-1);

        MinSec2Rating::iterator it2, it1;
        it2=Sinneinheiten.find(Endmoment);

        if (it2 != Sinneinheiten.end()) // IntervallENDE existiert 
                temp.Einschaetzung=it2->second;
                
        if (it2 != Sinneinheiten.begin()) // IntervallANFANG existiert 
        {
                it1=it2;  it1--;                        // it1 = gehe einen Schritt zurück
                temp.EinschaetzungDavor=it1->second;
        }
        if (temp.Einschaetzung != error && temp.EinschaetzungDavor != error)
                temp.Dauer=(it1->first).secsTo(it2->first);

        return temp;
}

IntervallErgebnis RatingVerlauf::RatingAuslesen (const MinSec2Rating::iterator it){
        // TODO: Diese Routine tut eigentlich dasselbe wie
        // IntervallErgebnis RatingAuslesen (const MinSec &Endmoment)
        // nur noch ELEMENTARER, nämlich mit gegebenem Iterator
        // innerhalb der Map (statt einem Zeitpunkt, der erst gesucht werden muss)
        // TODO: dies sollte in obiges eingesetzt werden, 
        // um Redundanz zu vermeiden

        IntervallErgebnis temp(error, error,-1);

        MinSec2Rating::iterator it2, it1;
        it2=it;

        if (it2 != Sinneinheiten.end()) // IntervallENDE existiert 
                temp.Einschaetzung=it2->second;
                
        if (it2 != Sinneinheiten.begin()) // IntervallANFANG existiert 
        {
                it1=it2;  it1--;                        // it1 = gehe einen Schritt zurück
                temp.EinschaetzungDavor=it1->second;
        }
        if (temp.Einschaetzung != error && temp.EinschaetzungDavor != error)
                temp.Dauer=(it1->first).secsTo(it2->first);

        return temp;
}

QString RatingVerlauf::printRating (const MinSec &Endmoment){

        IntervallErgebnis gesamt;
        gesamt=RatingAuslesen(Endmoment);
        
        QString temp;
        temp=Endmoment.toQString();
        if ( gesamt.Dauer>=0 ) {
                temp+="\t"+gesamt.toQString();
        }
        return temp;
}

QString RatingVerlauf::printGesamtenRatingVerlauf (const MinSec& von, 
                                                                                                   const MinSec& bis){
        qDebug("printGesamtenRatingVerlauf sollte NICHT verwendet werden, "
                   "da a) suboptimal und b) riesiger QString als Resultat");
        MinSec2Rating::iterator it;
        MinSec Zeitpunkt;
        QString temp="";
        if ( bis < von ) 
                return temp;
        
        for (it=Sinneinheiten.lower_bound(von); it != Sinneinheiten.end(); ++it){
                Zeitpunkt=(*it).first;
                if (bis < Zeitpunkt) 
                        break;

                      // suboptimal, weil darin noch ein map::find()
                temp+=printRating(Zeitpunkt); 
                temp+="\n";
        }
                
        return temp;
}

bool RatingVerlauf::liesGesamtenRatingVerlauf (QTextStream &s){

        Sinneinheiten.clear();
        
        int Einschaetzung;
        MinSec Zeitpunkt;
        bool OK;
        QString Wort; 
        QChar c;

leseSchleife:
        while (! s.atEnd()){

                OK=Zeitpunkt.liesVonTextStream(s);
                if (!OK) {
                                        qDebug("Fehler beim Einlesen des Zeitpunktes");
                                        return false;
                                }
                s >> c;
                switch (c) {
                        case '\t':
                                s >> Wort;
                                Einschaetzung=Wort.toInt(&OK);
                                if (!OK) {
                                        qDebug("Fehler beim Umwandeln der Einschaetzung");
                                        return false;
                                }
                                RatingAnhaengen(Zeitpunkt, (RatingSkala) Einschaetzung);

                                s >> c >> Wort     >> c >> Wort >> c >> Wort >> c >> Wort >> c;
                                //  tab  EinschDavor tab   dauer  tab   Klient  tab  Rater  tab
                                
                                if (c!='\n'){  // falls uralte Version, dann ist die Zeile hier zuende
                                        s >> Wort >> c  >> Wort >> c >>     Wort    >> c;
                                //      minuten TAB  Sekunden TAB  Millisekunden   BR
                                }

                                if (c!='\n') {
                                        qDebug("Rest der Zeile war nicht OK"); 
                                        return false;
                                }
                        break;
                        case '\n':
                                goto leseSchleife; // nächste Zeile, weil nur 00:00, 
                                                   // mittlerweile obsolet
                         break;
                        default:
                                qDebug("Quatsch beim Einlesen");
                                return false;
                         break;
                }
        }
        return true;
}


bool RatingVerlauf::speichereGesamtenRatingVerlauf (QTextStream &s, 
                                                                QString& derKlient, QString& derRater) {

        MinSec Zeitpunkt=MinSec(0,0), ZeitpunktDavor=MinSec(0,0);
        RatingSkala Einsch=null, EinschDavor=null;
        double Dauer=0;
        MinSec2Rating::iterator it;
        it = Sinneinheiten.begin();

    for ( ; it!= Sinneinheiten.end(); ++it){
                ZeitpunktDavor=Zeitpunkt;
                Zeitpunkt=it->first;
                Dauer=(Zeitpunkt - ZeitpunktDavor).toSecs(); 

                EinschDavor=Einsch;
                Einsch=it->second;

                s << Zeitpunkt.toQString() << '\t';
                s << Einsch << '\t';
                s << EinschDavor << '\t';
                s << Dauer << '\t';
                s << derKlient << '\t';
                s << derRater << '\t';
                s << Zeitpunkt.mins() << '\t';
                s << (int) Zeitpunkt.secs() << '\t';
                s << Zeitpunkt.millisecs() << '\n';
        }       
        return true; // TODO: Was passiert, wenn innerhalb zB Platte voll?
}


// TODO: noch nicht auf Richtigkeit ge-check-t
int RatingVerlauf::verkuerzeUmAufeinanderfolgendGleiche(){

        RatingVerlauf kuerzer;
        long anzahlGekuerzter=0;

        IntervallErgebnis interv;
        RatingSkala letzteEinschaetzung = error;
        MinSec letzterZeitpunkt = MinSec(0,0);

        MinSec2Rating::iterator it;
        it = Sinneinheiten.begin();
        for ( ; it != Sinneinheiten.end() ; it++){
                interv=RatingAuslesen(it);
                if (interv.Einschaetzung != letzteEinschaetzung) {
                        // falls DIESE Einschätzung anders, dann speichere die LETZTE
                        kuerzer.RatingAnhaengen(letzterZeitpunkt, letzteEinschaetzung );
                } else{
                        // sonst ignorier DIESE und incrementiere nur Zähler
                        anzahlGekuerzter++;
                }
                letzteEinschaetzung=interv.Einschaetzung;
                letzterZeitpunkt=it->first;
        }
        // TODO: Stimmt das? Der letzte wird NIE eingefügt, oder?
        kuerzer.RatingAnhaengen(letzterZeitpunkt, letzteEinschaetzung );


        this->RatingLoeschen(MinSec(0,0)); // leere sicherheitshalber aktuelle Map
        this->Sinneinheiten = kuerzer.Sinneinheiten; // TODO: ist das ein COPY ?
        return anzahlGekuerzter;
}

void RatingVerlauf::testRatingVerlauf() {

        qDebug("\nRatingVerlauf::testRatingVerlauf");
        RatingAnhaengen (MinSec(0,13,100), TL);
        RatingAnhaengen (MinSec(0,23.9), TNL);
        RatingAnhaengen (MinSec(0,37.6), KNL);
        RatingAnhaengen (MinSec(1,10,0), KL);

        qDebug("letzter Moment " + BisherLetzterMoment().toQString() );

    MinSec EndMoment;
        EndMoment=MinSec(1,10);
        IntervallErgebnis ges;
        ges=RatingAuslesen(EndMoment);
        qDebug(ges.toQString());

        qDebug(printRating (MinSec(0,0))); 
        qDebug(printRating (MinSec(0,13.1)));
        qDebug(printRating (MinSec(0,23.9)));
        qDebug(printRating (MinSec(0,37.6)));
        qDebug(printRating (MinSec(1,10)));
        qDebug(printRating (MinSec(1,11)));

        qDebug("\n\nUnd nun alles in einer Routine:");
        qDebug(printGesamtenRatingVerlauf (MinSec(0,0), BisherLetzterMoment()));

        qDebug("\n\nUnd nun nur die mittleren 3:");
        qDebug(printGesamtenRatingVerlauf (MinSec(0,12), MinSec(0,38)));
};


void testMinSecMap(){
        qDebug("\n\ntestMinSecMap();");   
        MinSec2Rating verlauf;
        MinSec2Rating::iterator theIterator;

        MinSec Endzeitpunkt=MinSec(1,12);
        verlauf.insert(MinSec2Rating::value_type(Endzeitpunkt,error));
        Endzeitpunkt=Endzeitpunkt.addSecs(7.2);
        verlauf.insert(MinSec2Rating::value_type(Endzeitpunkt,KL));
        Endzeitpunkt=Endzeitpunkt.addSecs(-69.9);
        verlauf.insert(MinSec2Rating::value_type(Endzeitpunkt,null));
        verlauf.insert(MinSec2Rating::value_type(Endzeitpunkt,KNL));
        // Sollte Werte ergeben bei 
        // 00:09.300
        // 01:12.000
        // 01:19.200

        theIterator = verlauf.begin();
    for ( ; theIterator!= verlauf.end(); ++theIterator)
        qDebug((*theIterator).first.toQString()+" %d", (*theIterator).second);

        MinSec Endzeitpunkt2=Endzeitpunkt.addSecs(1);
        ;
        MinSec2Rating::key_compare vergleiche=verlauf.key_comp();
        qDebug("a eine Sekunde kleiner als b");
        qDebug("vergleich<: %d",vergleiche(Endzeitpunkt, Endzeitpunkt2));
        qDebug("vergleich>=: %d",vergleiche(Endzeitpunkt2, Endzeitpunkt));

        qDebug("Bekannter Eintrag bei MinSec(1,19.2): %d",
                verlauf.find(MinSec(1,19.2))->second);
        qDebug("Bekannter Eintrag bei MinSec(1,19,200): %d",
                verlauf.find(MinSec(1,19,200))->second);
        qDebug("Unbekannter Eintrag(MinSec(1,18)) liefert: end() ): %d",
                verlauf.find(MinSec(1,18))->second);

        qDebug("bounds liefern gleichen, höheren key oder end()");
    theIterator=verlauf.lower_bound(MinSec(1,11));
        qDebug("lower bound (1:11): "+ theIterator->first.toQString());
        theIterator=verlauf.upper_bound(MinSec(1,11));
        qDebug("upper bound (1:11): "+ theIterator->first.toQString());

    theIterator=verlauf.lower_bound(MinSec(1,20));
        qDebug("lower bound (1:20): "+ theIterator->first.toQString());
        theIterator=verlauf.upper_bound(MinSec(1,20));
        qDebug("upper bound (1:20): "+ theIterator->first.toQString());

        qDebug("Bei Treffer: lower bound liefert gleichen, "
                   "upper bound liefert höheren key (oder end())");
    theIterator=verlauf.lower_bound(MinSec(1,12));
        qDebug("lower bound (1:12): "+ theIterator->first.toQString());
        theIterator=verlauf.upper_bound(MinSec(1,12));
        qDebug("upper bound (1:12): "+ theIterator->first.toQString());
        theIterator=verlauf.upper_bound(MinSec(1,19.2));
        qDebug("upper bound (1:19.200): "+ theIterator->first.toQString());

        qDebug("\nAlso für schon verbrauchte Zeitpunkten: ");
        qDebug("Suche nach lower_bound(Reglerstand), rot wenn != end();");
        qDebug("(Oder besser einfach direkter Vergleich mit "
                   "MinSec BisherLetzterMoment())\n");
};

---