DataTyps.h

#pragma once
#include <QColor>


typedef struct PowerAnalysisSetting{
    double ws,wd;           
    double m;               
    double cr;              
    double T;               
    double p0;              
    double Pvd,Pmax,PT;     
    double cwAvd, cwAmax,cwAmin,cwAT;
    int fightwind;
    double abrake;          
    double aradial;         
}PowerAnalysisSetting;

/*OSM*/
enum branch {l,r,lefttop,leftbottom};
enum readdirection {fw,bw};
enum inputstate {routeshort, routeflat, routemountain,routeclimb,
                 routeSTRONG,editdata,selectlayer, routetwitch};
enum climbstate {increasing, decreasing, outofuse, climbstart, climbend, failure};
enum dotstate {crossdot, waydot, nonedot, crossdotmarked};
struct STRONG;
struct KOO;
struct Way;


typedef struct trackpoint{
    float h,d;
}trackpoint;

typedef struct Neighbour{
    readdirection rd;
    Way *way;                           
    KOO *nb;                            
    Neighbour *brthr;
    float hm;                           
    float d;                            
    int nodec;                          
    int tpc;                            
    KOO** node;                         
    trackpoint* tp;                     
    Neighbour* next;                    
}Neighbour;

typedef struct crossdata{
    Neighbour *neighbours;             
    STRONG *s;                          
}crossdata;

typedef struct KOO {
    qint64 id;                          
    char balance;                       
    KOO *l,*r,*prev;                    
    double lon,lat;                     

    char status;
    crossdata* cd;                      
} KOO;

typedef struct Way {
    qint64 id;                          
    int nodec;                          
    KOO** node;                         
    float minlat,minlon,maxlat,maxlon;  
    Way *l,*r,*prev;                    
    short balance;                      
    char type;                          
    char* name;                         
} Way;
typedef struct OSM_Data{
    KOO** nodes;
    Way** waysavl;
} OSM_Data;
typedef struct points{
    KOO* k;                             
    float index;                        
    char* name;                         
    points* next, *prev;}points;
typedef struct lines{
    Way* way;                           
    lines* next;
    char* name;                         
}lines;
typedef struct relation{
    Way** members;
    int memberscount;
    char type;
    relation* next;
}relation;



typedef struct trackpointlist{
    trackpoint t;
    trackpointlist *prev,*next;
}trackpointlist;

typedef struct KOOlist{
    KOO* k;                             
    KOOlist *prev,*next;
    float d;
    short marked;
    int tpi;
}KOOlist;

/*MAP*/
typedef struct SunSetting{
    float azimut,elevation;
    float I;                            
    float sphi;                         
    float cphi;                         
    float stheta;                       
    float ctheta;                       
}SunSetting;

/*Profil*/
typedef struct ProfilSettings{
    QRgb bgcolor,fontcolor,latticecolor;
    bool drawybarlabel,drawxbarlabel,drawtitle,
        drawxlattice,drawylattice;
    int fsnormal, fstitle;              //Schriftgroessen;
    char font[100];
    double xmax,xmin,ymax,ymin;
    int margin;
    int width, height;
    bool autoscale;
    bool singlecolor;
    QRgb fillcolor;
    bool showline;
    QRgb linecolor;
    bool showreduceddata;
}ProfilSettings;

/*Profil*/
typedef struct MapSettings{
    double minlat,minlon,maxlat,maxlon; 
    QRgb roadcolor[6];                  
    float roadwidth[6];                 
    QRgb summitcolor;
    float summitsize;
    float pointsize[6];                 
    QRgb pointcolor[6];                 
    bool drawcontour;
    bool drawsummit;
    bool drawpoints;
    bool drawwood;
    bool drawstreetcontour;
    QRgb woodcolor;
    bool drawater;
    QRgb watercolor;
    bool drawscale;
    bool drawstreetlabel;
    QRgb heightcolor[5];                
    double heights[5];                  
    double climblayershading;
    SunSetting sun;                     
}MapSettings;

/*Routing*/

typedef struct STRONG{
    void* from;
    Neighbour* via;                     
}STRONG;
class STRONGfib{
public:
    float d;                            
    float hm;                           
    STRONG* from;                       
    KOO* k;                             
    Neighbour* via;                     
};
class STRONGPlusfib : public STRONGfib{
public:
    float hmup;

    float hmdown;
};
class STRONGClimbfib : public STRONGPlusfib{
public:
    float Psum, dP;
};
typedef struct STRONGsetting{

    double rfac, rabs;
    int hmstep;                         
    int hmmax;                          
    double hmperkm;                     
    short dhmin;                        
    float downtoupmax;                  
    float minP;                         
    bool noSTRONGPlus;                  
    bool ClimbInsteadHm;                
}STRONGsetting;
typedef struct ClimbAnalyseSettings{
    double minP;                        
    double minS;                        
    double maxdwnHM;                    
    double minHM;                       
    bool html;                          
    bool map;                           
    bool list;                          
    char ProjectFolder[260];            
    char ProjectName[260];              
    double mapsize;                     
    bool Climblayer;                    
}ClimbAnalyseSettings;
typedef struct ExtMapSettings{
    double minlat,minlon,maxlat,maxlon; 
    double mapsize;                     
    bool drawCL;                        
    bool drawSL;                        
    bool drawct;                        
}ExtMapSettings;
typedef struct config {
    MapSettings MS;
    char mintype,maxtype;               
    STRONGsetting mconfig;              
    STRONGsetting sconfig;              
    STRONGsetting cconfig;              
    char SRTM3folder[260];              
    char start_btp[260];                
    inputstate input;                   
    int drawSTRONGlayer;                
    int drawRoute;                      
    int drawClimblayer;                 
    ClimbAnalyseSettings CA;
    ProfilSettings PS;
    PowerAnalysisSetting PA;
    int plotspeed;                      
    int plotpower;                      

}config;
typedef struct STRONGlayerele{
    Neighbour* n;                       
    float index;                        
}STRONGlayerele;
typedef struct STRONGlayer{
    STRONGlayerele* data;
    int ncount;                         
    STRONGlayer* prev;
    STRONGlayer* next;
}STRONGlayer;

/*WayHeight*/
typedef struct PortionInstruction{
    double cos;
    trackpoint *dest;
}PortionInstruction;
typedef struct PortionInstructionCol{
    Neighbour* nb;
    PortionInstruction* PI;
    double SumCos;
    int Pcount;
    trackpoint *src;
    PortionInstructionCol* next;
}PortionInstructionCol;

/*ClimbAnalyse*/
typedef struct nbpoolele{
    int mintp;
    Neighbour* nb;
}nbpoolele;
typedef struct crosspoolele{
    float h;
    KOO* k;
}crosspoolele;
typedef struct climb{
    climbstate state;                   
    short branches;                     
    KOO* home;                          
    trackpointlist* t;                  
    trackpointlist* tst;                
    trackpointlist* tend;               
    float P, Pmax, Prec, d, hend, hstart, hmdown,hmup;
    climb * next,*prev;
    climb *cst;                         
    climb *root;                        
    Neighbour* via;                     
}climb;
typedef struct CAfib{
    float h;                            //Distanz der KOO
    climb* c;
}CAfib;
class Cfib : public STRONGfib{
public:
    float hmup,hmdown,P;
};                              //Hilfstruktur fuer ClimbDijkstra

typedef struct climblayerelement{
    double **dharray;
    int dhcount;
    double **KOOarray;
    int KOOcount;
    char* name;
    float P,d, hend, hstart, hmdown,hmup, slope,bend,LocRank;
    double midlat,midlon;
}climblayerelement;
typedef struct climblayer{
    climblayerelement* climb;
    long climbcount;
    climblayer* prev;
    climblayer* next;
}climblayer;
typedef struct templatepoint{
    int x,y;
    int dx,dy;
    short rprev;
    short rnext;
}templatepoint;