strongcalc.h

#ifndef STRONGCALC_H
#define STRONGCALC_H
#include <QThread>
#include "DataTyps.h"
#include "Track.h"
#include "fibunacci.h"
#include "osm.h"

enum RunMode {RMcalc,RMcalcRestricted,RMcalcClimb,RMcalcClimbRestricted,RMload,RMsave};

class STRONGcalc: public QThread{
Q_OBJECT
public:
    STRONGcalc(OSM* o, KOO* s, KOO* e,char max, char min,
               STRONGsetting* hs,Track*** trck, int* N, bool Hmonly);
    STRONGcalc(OSM* o, int N, char* filename,Track***results);
    STRONGcalc(OSM* o, int*N, char* filename,Track*** results);
    void run();
    void exit();
public slots:
    void stop_calculations();
signals:
    void finished(int succesful);
    void refresh_progress(int step);
private:
    int counter;

    template <class T> void calc(FibunacciHeap<T>**f);

    void init_Strong();
    void init_StrongPlus();
    void init_StrongClimb();

    void init_AreaStrong(KOO* k);
    void init_AreaStrongPlus(KOO* k);
    void init_AreaStrongClimb(KOO* k);

    void setSTRONG(KOO* k);

    short traceback(STRONG* s, Neighbour* n);
    int index_STRONG(STRONGfib* t,Neighbour* n);
    int index_STRONG(STRONGPlusfib* t,Neighbour* n);
    int index_STRONG(STRONGClimbfib* t,Neighbour* n);
    void store_STRONG(STRONGfib* t, Neighbour* n,int si, int i);
    void store_STRONG(STRONGPlusfib* t, Neighbour* n,int si, int i);
    void store_STRONG(STRONGClimbfib* t, Neighbour* n,int si, int i);

    void STRONG_to_trck(int i);

    void extract_neighbourlist(STRONG* s, STRONG* e,
                               Neighbour ***nl,long int* nc);
    int extract_STRONGPlus_restriciton(Neighbour* n);
    int extract_STRONGClimb_restriciton(Neighbour* n);
    void load_STRONG();
    void save_STRONG();
    void load_crossdata(FILE* f);
    void save_crossdata(KOO *k, FILE* f);
    RunMode runmode;                    
    OSM* o;                             
    char filename[999];                 
    KOO *s;                             
    KOO *e;                             
    char max, min;                      
    STRONGsetting* hs;                  
    Track*** trck;                      
    /*Variablen des STRONG-Algorithmus*/
    int N, *Nout, calcstopped;
    float radius;
    short foundSTRONG;                  
    Neighbour *dummy;                   
    FibunacciHeap<STRONGfib>** f;
    FibunacciHeap<STRONGPlusfib>** fplus;
    FibunacciHeap<STRONGClimbfib>** fclimb;
    double* mind;                       
    STRONG** mindSTRONG;
    float hm, hmup, hmdown, Psum, dP;
};

#endif // STRONGCALC_H