gpx.cpp

#include "gpx.h"


gpx::gpx(char* filename){
    file = filename;
    l = NULL;
    if(file != NULL){
        read_in();
        calc_distance();
    }
}
gpx::~gpx(){
}
void gpx::add_point(double lon, double lat, double h, long int time){
    gpxlist* g;
    if(l != NULL){
        (*l)->prev->next = new gpxlist;
        g = (*l)->prev->next;
    }
    else{
        l = new gpxlist*;
        *l = new gpxlist;
        g = *l;
        (*l)->prev = g;
    }
    g->prev = (*l)->prev;
    (*l)->prev = g;
    g->next = NULL;
    g->d = 0;
    g->lat = lat;
    g->lon = lon;
    g->h = h;
    g->time = time;
}
void gpx::read_in(){
    FILE* f = fopen(file,"r");
    if(f != NULL){
        /*Datei existiert*/
        char line[10000],*readstart,*newstart;
        double lon = 0, lat = 0, h = 0;
        long int time;
        int read_out;
        while(!feof(f)){
            /*Zeilenweise einlesen*/
            fgets(line,10000,f);
            replace_quotation(line);
            read_out = 0;
            readstart = line;
            while(!read_out){
                newstart = strstr(readstart,"</trkpt>");
                if (newstart != NULL){
                    newstart[0] = '\0';
                    newstart = &newstart[1];
                }
                else{
                    read_out = 1;
                }
                extract_attribute("lat",readstart,&lat);
                extract_attribute("lon",readstart,&lon);    
                extract_element("ele",readstart,&h);
                extract_time(readstart,&time);

                if(!read_out){
                    add_point(lon,lat,h,time);
                    readstart = newstart;
                }
            }
        }
    }
}
void gpx::replace_quotation(char* a){
    int i = 0;
    while(a[i] != '\0'){
        if(a[i] == '\"')
            a[i] = '\'';
        i++;
    }
}
void gpx::extract_attribute(const char* attr, char* src, double* result){
    char *x1;
    char *x2;
    x1 = strstr(src, attr);
    if(x1 != NULL){
        x1 = &x1[strlen(attr)+2*sizeof(char)];
        x2 = strchr(x1,'\'');
        x2[0] = '\0';
        *result = atof(x1);
        x2[0] = '\'';
    }
}
void gpx::extract_element(const char* elem, char* src, double* result){
    char *x1;
    char *x2;
    char pattern[100];
    strcpy(&pattern[2],elem);
    pattern[1]='<';
    pattern[2+strlen(elem)] = '>';
    pattern[3+strlen(elem)] = '\0';
    x1 = strstr(src,&pattern[1]);
    if(x1 != NULL){
        x1 = &x1[strlen(pattern)-1];
        pattern[1] = '/';
        pattern[0] = '<';
        x2 = strstr(src,pattern);
        x2[0] = '\0';
        *result = atof(x1);
        x2[0] = '<';
    }
}
void gpx::extract_time(char* src, long int* unix_time){
    char *x1,*x2;
    char pattern[] = "</time>";
    pattern[1]='<';
    x1 = strstr(src,&pattern[1]);
    if(x1 != NULL){
        x1 = &x1[strlen(pattern)-1];
        pattern[1] = '/';
        x2 = strstr(src,pattern);
        x2[0] = '\0';
        int totaldays,year,month,day,hour,minute,second;
        char *x3 = strstr(x1,"T");
        if(x3 != NULL){
            x1 = x1;        x1[4]='\0';     year = atoi(x1);    x1[4]='-';
            x1 = &x1[5];    x1[2]='\0';     month = atoi(x1);   x1[2]='-';
            x1 = &x1[3];    x1[2]='\0';     day = atoi(x1);     x1[2]='T';
            x1 = &x3[1];    x1[2]='\0';     hour = atoi(x1);    x1[2]=':';
            x1 = &x1[3];    x1[2]='\0';     minute = atoi(x1);  x1[2]=':';
            x1 = &x1[3];    x1[2]='\0';     second = atoi(x1);  x1[2]='Z';
            
            int is_leap_year = 0;
            if( year % 4 == 0 
                && (((year-1901) % 100 != 0) || ((year-1901) % 400 == 0))) 
                is_leap_year = 1;
            
            /*Tage seit 1970 inkl. Schalt- und Saekularisierungsjahr*/
            totaldays = (year-1970)*365;                //normale Tagesanzahl
            totaldays = totaldays + (year-1969) / 4;    //Schaltjahr normal
            totaldays = totaldays - (year-1901) / 100;  //Seakularisierung 1
            totaldays = totaldays + (year-1601) / 400;  //Seakularisierung 2

            /*Aufschlüsselung der Monatstage*/
            switch(month){
                case 12: totaldays = totaldays + 30;
                case 11: totaldays = totaldays + 31;
                case 10: totaldays = totaldays + 30;
                case  9: totaldays = totaldays + 31;
                case  8: totaldays = totaldays + 31;
                case  7: totaldays = totaldays + 30;
                case  6: totaldays = totaldays + 31;
                case  5: totaldays = totaldays + 30;
                case  4: totaldays = totaldays + 31;
                case  3: totaldays = totaldays + 28 + is_leap_year;
                case  2: totaldays = totaldays + 31;
            }

            *unix_time =  24*60*60 * (totaldays + (day -1))
                        +    60*60 * hour
                        +       60 * minute 
                        +            second;
        }
        x2[0] = '<';
    }
}
void* gpx::get_complete_List(){
    return l;
}
void gpx::calc_distance(){
    if(l != NULL){
        (*l)->d = 0;
        gpxlist *g = (*l)->next;
        while(g != NULL){
            g->d = g->prev->d 
                   + distance(g->lat,g->lon,g->prev->lat,g->prev->lon);
            g = g->next;
        }
    }
}
double gpx::distance(double lat1, double lon1, double lat2, double lon2){
    if (lat1 == lat2 && lon1 == lon2) return 0;
    else{
        return
        acos(cos(lat2/180*M_PI)*cos(lat1/180*M_PI)*
        (cos(lon2/180*M_PI-(lon1)/180*M_PI))+sin(lat2/180*M_PI)
        *sin((lat1)/180*M_PI))*R0;
    }
}
double** gpx::get_complete(long int* n){
    *n = 0;
    double** result;
    if(l != NULL){
        gpxlist *g = *l;
        while(g != NULL){
            (*n)++;
            g = g->next;
        }
        
        g = *l;
        result = new double*[5];
        for(int i = 0; i < 5; i++)
            result[i] = new double[*n];
        for(int i = 0; i < *n; i++){
            result[0][i] = g->d;
            result[1][i] = g->h;
            result[2][i] = g->lat;
            result[3][i] = g->lon;
            result[4][i] = g->time;
            g = g->next;
        }
    }
    else
        result = NULL;

    return result;
}