track.cpp

#define _USE_MATH_DEFINES
#include "Track.h"

Track::Track(){
    tpl = NULL;
    kl = NULL;
    kc = 0;
    tc = 0;
    d_h_array = NULL;
    KOOpool = NULL;
    keep_lists = 0;
}
Track::Track(double** KOOarray, int count){
    KOOa = NULL;
    KOOpool = NULL;
    kl = new KOOlist[count];
    for(int i = 0; i < count; i++)
        kl[i].k = add_to_KOOpool(KOOarray[0][i],KOOarray[1][i]);
    kl[0].d = 0;
    for(int i = 1; i < count; i++)
        kl[i].d = distance(KOOarray[0][i],KOOarray[1][i],
                           KOOarray[0][i-1],KOOarray[1][i-1])
                  + kl[i-1].d;

    tc = 0;
    kc = count;
    keep_lists = 0;
    d_h_array = NULL;
    tpl = NULL;
}
Track::Track(trackpoint* tpl,int tc, KOOlist* kl, int kc){
    this->tc = this->kc = 0;
    this->tpl = NULL;
    this->kl = NULL;
    add(tpl,tc,kl,kc);
    d_h_array = NULL;
    KOOa = NULL;
    KOOpool = NULL;
    keep_lists = 1;
    reset_markers();
}
Track::Track(double *d,double *h,double *lat,double *lon,int count){
    kl = new KOOlist[count];
    kc = count;
    tpl  = new trackpoint[count];
    tc = count;
    for(int i = 0; i < count; i++){
        kl[i].k->lat = lat[i];
        kl[i].k->lon = lon[i];
        kl[i].tpi = i;
        kl[i].d = d[i];
        tpl[i].d = d[i];
        tpl[i].h = h[i];
    }
    KOOa = NULL;
    d_h_array = NULL;
    KOOpool = NULL;
    keep_lists = 0;
}

Track::Track(Neighbour** narray, int nc){
    /*calc list lengths*/
    tc = kc = 1;
    for(int i = 0; i < nc; i++){
        kc += narray[i]->nodec -1;
        tc += narray[i]->tpc -1;
    }

    tpl = new trackpoint[tc];
    kl = new KOOlist[kc];
    /*Listen initialisieren*/
    if(narray[0]->rd == fw){
        tpl[0] = narray[0]->tp[0];
        kl[0].k = narray[0]->node[0];
    }
    else{
        tpl[0] = narray[0]->tp[narray[0]->tpc-1];
        tpl[0].d = 0;
        kl[0].k = narray[0]->node[narray[0]->nodec-1];
    }

    int cik = 0, cit = 0;
    kl[0].d = 0;
    kl[0].tpi = 0;
    float d0 = 0;
    /*Rekonstruktion starten*/
    for(int i = 0; i < nc; i++){
        if(narray[i]->rd == fw){
            d0 = kl[cik].d;
            for(int j = 1; j < narray[i]->nodec; j++){
                kl[cik+j].k = narray[i]->node[j];
                kl[cik+j].d = kl[cik+j-1].d
                              + distance(kl[cik+j  ].k->lat,kl[cik+j  ].k->lon,
                                         kl[cik+j-1].k->lat,kl[cik+j-1].k->lon);
                kl[cik+j].tpi = -1;;
            }
            for(int j = 1; j < narray[i]->tpc; j++){
                tpl[cit+j].h = narray[i]->tp[j].h;
                tpl[cit+j].d = narray[i]->tp[j].d + d0;
            }
            cik += narray[i]->nodec-1;
            cit += narray[i]->tpc-1;
        }
        else{
            d0 = kl[cik].d + narray[i]->tp[narray[i]->tpc-1].d;
            cik += narray[i]->nodec-1;
            cit += narray[i]->tpc-1;
            for(int j = narray[i]->nodec-2; j >= 0; j--){
                kl[cik-j].k = narray[i]->node[j];
                kl[cik-j].d = kl[cik-j-1].d
                            + distance(kl[cik-j  ].k->lat,kl[cik-j  ].k->lon,
                                       kl[cik-j-1].k->lat,kl[cik-j-1].k->lon);
                kl[cik-j].tpi = -1;
            }
            for(int j = narray[i]->tpc-2; j >= 0; j--){
                tpl[cit-j].h = narray[i]->tp[j].h;
                tpl[cit-j].d = d0 - narray[i]->tp[j].d;
            }    
        }
        kl[cik].tpi = cit;
        kl[cik].d = tpl[cit].d;
    }
    d_h_array = NULL;
    KOOa = NULL;
    KOOpool = NULL;
    keep_lists = 1;
    reset_markers();
}
Track::Track(Track* tracktocopy){
    tpl = NULL;
    kl = NULL;
    tc = kc = 0;
    KOOa = NULL;
    d_h_array = NULL;
    KOOpool = NULL;
    keep_lists = 0;
    if(tracktocopy != NULL)
        add(tracktocopy);
}
Track::~Track(){
    if(d_h_array != NULL){
        delete d_h_array[1];
        delete d_h_array[0];
        delete d_h_array;
    }
    free_KOOpool(KOOpool);
    if(!keep_lists)
        delete_complete();
}
void Track::add(trackpoint* tpl,int tc, KOOlist* kl, int kc){
    /*an KOOlist anhaengen*/
    if(this->kl == NULL){
        this->kl = new KOOlist[kc];
        memcpy(&(this->kl[0]),kl,kc*sizeof(KOOlist));
        this->kc = kc;
    }
    else{
        int newkc = this->kc + kc -1;
        KOOlist* newkl = new KOOlist[newkc];
        memcpy(&(newkl[0]),this->kl,this->kc*sizeof(KOOlist));
        memcpy(&(newkl[this->kc]),&(kl[1]),(kc-1)*sizeof(KOOlist));
        for(int i = 0; i < kc-1; i++){
            newkl[i+this->kc].d += this->kl[this->kc-1].d;
            if(newkl[i+this->kc].tpi >= 0)
                newkl[i+this->kc].tpi += this->tc - 1;
        }
        delete this->kl;
        this->kl = newkl;
        this->kc = newkc;
    }
    /*an Trackpoointlist anhaengen*/
    if(this->tpl == NULL){
        this->tpl  = new trackpoint[tc];
        memcpy(&(this->tpl[0]),tpl,tc*sizeof(trackpoint));
        this->tc = tc;
    }
    else{
        int newtc = this->tc + tc -1;
        trackpoint* newtpl = new trackpoint[newtc];
        memcpy(&(newtpl[0]),this->tpl,this->tc*sizeof(trackpoint));
        memcpy(&(newtpl[this->tc]),&(tpl[1]),(tc-1)*sizeof(trackpoint));
        for(int i = 0; i < tc-1; i++)
            newtpl[this->tc+i].d += this->tpl[this->tc-1].d;
        delete this->tpl;
        this->tpl = newtpl;
        this->tc = newtc;
    }
}
void Track::get_data_ref(trackpoint** tpl,int* tc, KOOlist** kl, int* kc){
    if(tpl != NULL) *tpl = this->tpl;
    if(tc  != NULL) *tc = this->tc;
    if(kl  != NULL) *kl = this->kl;
    if(kc  != NULL) *kc = this->kc;
}
void Track::add(Track* t2){
    if(t2 != NULL && t2->notNULL()){
        int atc,akc;
        KOOlist* akl;
        trackpoint* atpl;
        t2->get_data_ref(&atpl,&atc,&akl,&akc);
        add(atpl,atc,akl,akc);
    }
}
double** Track::get_d_h_array(){
    refresh_d_h_array();
    return d_h_array;
}
double** Track::get_d_h_array_copy(){
    refresh_d_h_array();
    double** result = d_h_array;
    d_h_array = NULL;
    return result;
}

double** Track::get_KOOa(){
    refresh_KOOa();
    return KOOa;
}
double** Track::get_KOOa_copy(){
    refresh_KOOa();
    double** result = KOOa;
    KOOa = NULL;
    return result;
}
void Track::refresh_d_h_array(){
    if(tpl != NULL){
        /*Alte Daten löschen*/
        if(d_h_array != NULL){
            delete d_h_array[0];
            delete d_h_array[1];
            delete d_h_array;
        }
        /*Neues Array erzeugen*/
        d_h_array = new double*[2];
        d_h_array[0] = new double[tc];
        d_h_array[1] = new double[tc];
        for(long int j = 0; j < tc; j++){
            d_h_array[0][j] = tpl[j].d;
            d_h_array[1][j] = tpl[j].h;
        }
    }
    else
        d_h_array = NULL;
}
void Track::refresh_KOOa(){
    if(kl != NULL){
        /*Alte Daten löschen*/
        if(KOOa != NULL){
            delete KOOa[0];
            delete KOOa[1];
            delete KOOa;
        }
        
        /*Neues Array erzeugen*/
        KOOa = new double*[2];
        KOOa[0] = new double[kc];
        KOOa[1] = new double[kc];
        for(long int j = 0; j < kc; j++){
            KOOa[0][j] = kl[j].k->lat;
            KOOa[1][j] = kl[j].k->lon;
        }
    }
    else
        KOOa = NULL;

}
long int Track::get_array_length(){
    return tc;
}
long int Track::get_KOOa_length(){
    return kc;
}
float Track::get_height_meters(){
    if(tpl != NULL){
        float result = 0;
        for(int i = 1; i < tc; i++)
            if(tpl[i].h - tpl[i-1].h > 0)
                result += tpl[i].h - tpl[i-1].h;
        return result;
    }
    else
        return 0;
}
float Track::get_height_meters(float dmin, float dmax){
    if(tpl != NULL){
        int ll = 0, lr = tc-1;
        while(ll+1 < lr && tpl[ll].d != tpl[lr].d){
            if(tpl[(ll+lr)/2].d > dmin)
                lr = (ll+lr)/2;
            else
                ll = (ll+lr)/2;
        }
        int rl = 0, rr = tc-1;
        while(rl+1 < rr && tpl[rl].d != tpl[rr].d){
            if(tpl[(rl+rr)/2].d > dmax)
                rr = (rl+rr)/2;
            else
                rl = (rl+rr)/2;
        }

        if(tpl[ll].d == tpl[lr].d || tpl[rl].d == tpl[rr].d)
            return 0.;
        else{
            float result = 0;
            for(int i = ll; i < rr; i++)
                if(tpl[i+1].h - tpl[i].h > 0)
                    result += tpl[i+1].h - tpl[i].h;
            if(tpl[lr].h > tpl[ll].h)
                result -= (tpl[lr].h - tpl[ll].h)
                        * (dmin-tpl[ll].d)/(tpl[lr].d-tpl[ll].d);
            if(tpl[rr].h > tpl[rl].h)
                result -= (tpl[rr].h - tpl[rl].h)
                        * (tpl[rr].d-dmax)/(tpl[rr].d-tpl[rl].d);
            return result;
        }
    }
    else
        return 0.;
}
double Track::get_length(){
    if(kl != NULL)
        return kl[kc-1].d;
    else
        return 0.;
}
KOO* Track::get_last_KOO(){
    if(kl != NULL)
        return kl[kc-1].k;
    else
        return NULL;
}
KOO* Track::add_to_KOOpool(double lat, double lon){
    KOO* k;
    if(KOOpool == NULL){
        k = new KOO;
        KOOpool = k;
    }
    else{
        KOOpool->prev->r = new KOO;
        k = KOOpool->prev->r;
        k->prev = KOOpool->prev;
    }
    k->lat = lat;
    k->lon = lon;
    k->r = NULL;
    k->l = NULL;
    k->cd = NULL;
    KOOpool->prev = k;
    return k;
}
void Track::free_KOOpool(KOO* k){
    if(k != NULL){
        free_KOOpool(k->l);
        free_KOOpool(k->r);
        delete k;
    }
}
short Track::extract_KOO(KOO* k, double d){
    if(kc > 0){
        int l = 0, r = kc-1;
        while(l+1 < r && kl[l].d != kl[r].d){
            if(kl[(l+r)/2].d > d)
                r = (l+r)/2;
            else
                l = (l+r)/2;
        }
        if(kl[l].d == kl[r].d)
            return 0;
        else{
            double dd = kl[r].d-kl[l].d;
            k->lat = kl[r].k->lat*(d-kl[l].d)/dd + kl[l].k->lat*(kl[r].d-d)/dd;
            k->lon = kl[r].k->lon*(d-kl[l].d)/dd + kl[l].k->lon*(kl[r].d-d)/dd;
            return 1;
        }
    }
    else
        return 0;
}
short Track::extract_h(double d, double* h){
    if(tc > 0){
        int l = 0, r = tc-1;
        while(l+1 < r && tpl[l].d != tpl[r].d){
            if(tpl[(l+r)/2].d > d)
                r = (l+r)/2;
            else
                l = (l+r)/2;
        }

        if(tpl[l].d == tpl[r].d)
            return 0;
        else{
            double dd = tpl[l].d-tpl[r].d;
            *h = tpl[r].h*(tpl[l].d-d)/dd + tpl[l].h*(d-tpl[r].d)/dd;
            return 1;
        }
    }
    else
        return 0;
}
short Track::extract_azimtut(double d, double* azimut){
    if(kc > 0){
        int l = 0, r = kc-1;
        while(l+1 < r && kl[l].d != kl[r].d){
            if(kl[(l+r)/2].d > d)
                r = (l+r)/2;
            else
                l = (l+r)/2;
        }
        if(kl[l].d == kl[r].d)
            return 0;
        else{
            *azimut = atan2((kl[r].k->lon-kl[l].k->lon)
                            *cos((kl[r].k->lat+kl[l].k->lat)/360.*M_PI),
                            kl[r].k->lat-kl[l].k->lat);
            return 1;
        }
    }
    else
        return 0;

}

short Track::next_d(double lat, double lon, double* d){
    if(kl != NULL){
        double dmin = distance(lat,lon,kl[0].k->lat,kl[0].k->lon), a,b,c,h;
        *d = 0;
        a = dmin;
        for(int i = 1; i < kc; i++){
            b = a;
            a = distance(       lat,        lon,kl[i].k->lat,kl[i].k->lon);
            c = kl[i].d - kl[i-1].d;
            if(a*a + c*c <= b*b){
                /*Punkt steht hinter kl[i].k*/
                if(a < dmin){
                    dmin = a;
                    *d = kl[i].d;
                }
            }
            else{
                if(b*b + c*c <= a*a){
                    /*Punkt steht vor kl[i-1].k*/
                    if(b < dmin){
                        dmin = b;
                        *d = kl[i-1].d;
                    }
                }
                else{
                    /*Punkt steht über Strecke*/
                    h = sqrt((4*a*a*b*b-(c*c-a*a-b*b)*(c*c-a*a-b*b))/(4*c*c));
                    if( h < dmin){
                        dmin = h;
                        *d = kl[i-1].d + sqrt(b*b-h*h);
                    }
                }
            }
        }
        return 1;
    }
    else
        return 0;
}
void Track::delete_cross(int nr){
    if(kl != NULL){
        int c = 0;
        int ci = kc-1;
        while(ci >= 0 && (c < nr || kl[ci].k->cd == NULL)){
            if(kl[ci].k->cd != NULL && kl[ci].tpi >= 0)
                c++;
            ci--;
        }
        trim_right(ci,kl[ci].tpi);
    }

}
void Track::delete_to_cross(KOO* k){
    short ci = -1;

    for(int i = kc-1; i >= 0; i--)
        if(kl[i].k == k){
            ci = i;
            i = -1;
        }
    if(ci == 0){
        // Track is totaly lost
        delete tpl;
        delete kl;
        kc = 0;
        tc = 0;
        tpl = NULL;
        kl = NULL;
    }

    if(ci > 0){
        kc = ci + 1;
        tc = kl[ci].tpi+1;
        realloc(kl,kc*sizeof(KOOlist));
        realloc(tpl,tc*sizeof(trackpoint));
        kl[ci].marked = 1;
    }
}
void Track::delete_complete(){
    if(kl != NULL){
        delete kl;
        kl = NULL;
        kc = 0;
    }
    if(tpl != NULL){
        delete tpl;
        tpl = NULL;
        tc = 0;
    }
}
short Track::notNULL(){
    if(kl != NULL)
        return 1;
    else
        return 0;
}
short Track::near_check(double lat, double lon, double limit){
    if(kl != NULL){
        limit = limit*limit;
        int ci = 0;
        double lonc = cos(kl[ci].k->lat/180*M_PI)*cos(kl[ci].k->lat/180*M_PI);
        while(ci < kc
              &&(kl[ci].k->lat-lat)*(kl[ci].k->lat-lat)
                +(kl[ci].k->lon-lon)*(kl[ci].k->lon-lon)*lonc >limit
              )
            ci++;
        if(ci < kc)
            return 1;
        else
            return 0;
    }
    else
        return 0;
}
void Track::trim_right(float d){
    if(d < kl[kc-1].d && d < tpl[tc-1].d){
        double h;
        extract_h(d,&h);
        KOO* k = add_to_KOOpool(0,0);
        extract_KOO(k,d);
        int kci = kc-1;
        while(kci > 0 && kl[kci].d > d)
            kci--;
        kci++;
        kl[kci].k = k;
        kl[kci].d = d;
        kl[kci].marked = 1;

        int tci = tc-1;
        while(tci > 0 && tpl[tci].d > d)
            tci--;
        tci++;
        tpl[tci].d = d;
        tpl[tci].h = h;

        trim_right(kci,tci);
    }
}
void Track::trim_left(float d){
    if(d > kl[0].d && d > tpl[0].d){
        double h;
        extract_h(d,&h);
        KOO* k = add_to_KOOpool(0,0);
        extract_KOO(k,d);
        int kci = 0;
        while(kci < kc && kl[kci].d < d)
            kci++;
        kci--;
        kl[kci].k = k;
        kl[kci].d = d;
        kl[kci].marked = 1;


        int tci = 0;
        while(tci < tc && tpl[tci].d < d)
            tci++;
        tci--;
        tpl[tci].d = d;
        tpl[tci].h = h;

        trim_left(kci,tci);
    }
}
void Track::trim_left(KOO* k){
    if(k != kl[0].k){
        int kci = -1;
        for(int i = 0; i < kc; i++)
            if(kl[i].k == k){
                kci = i;
                i = kc;
            }
        int tci = kl[kci].tpi;

        trim_left(kci,tci);
    }
}
void Track::trim_right(KOO* k){
    if(k != kl[kc-1].k){
        int kci = -1;
        for(int i = kc-1; i >= 0; i--)
            if(kl[i].k == k){
                kci = i;
                i = -1;
            }
        int tci = kl[kci].tpi;
        trim_right(kci,tci);
    }
}
void Track::trim_left(int kci, int tci){
    if(kci == kc-1 || tci == tc-1)
        delete_complete();
    else{
        kc -= kci;
        KOOlist* newkl = new KOOlist[kc];
        memcpy(&(newkl[0]),&(kl[kci]),kc*sizeof(KOOlist));
        delete kl;
        kl = newkl;

        tc -= tci;
        trackpoint* newtpl = new trackpoint[tc];
        memcpy(&(newtpl[0]),&(tpl[tci]),tc*sizeof(trackpoint));
        delete tpl;
        tpl = newtpl;

        for(int i = kc - 1; i >= 0; i--){
            kl[i].d -= kl[0].d;
            if(kl[i].tpi >= 0)
               kl[i].tpi -= tci;
        }

        for(int i = tc - 1; i >= 0; i--)
            tpl[i].d -= tpl[0].d;

        if(kl[0].k->cd != NULL)
            kl[0].marked = 1;
        else
            kl[0].marked = 0;
    }
}
void Track::trim_right(int kci, int tci){
    if(kci == 0 || tci == 0)
        delete_complete();
    else{
        kc = kci + 1;
        KOOlist* newkl = new KOOlist[kc];
        memcpy(&(newkl[0]),kl,kc*sizeof(KOOlist));
        delete kl;
        kl = newkl;

        tc = tci + 1;
        trackpoint* newtpl = new trackpoint[tc];
        memcpy(&(newtpl[0]),tpl,tc*sizeof(trackpoint));
        delete tpl;
        tpl = newtpl;

        kl[kc-1].tpi = tci;

        if(kl[kc-1].k->cd != NULL)
            kl[kc-1].marked = 1;
        else
            kl[kc-1].marked = 0;
    }

}
void Track::invert(){
    if(kl != NULL){
        KOOlist* newkl = new KOOlist[kc];
        for(int i = 0; i < kc; i++){
            newkl[i] = kl[kc-1-i];
            newkl[i].d = kl[kc-1].d-newkl[i].d;
            if(newkl[i].tpi >= 0)
                newkl[i].tpi = tc - 1 - newkl[i].tpi;
        }
        delete kl;
        kl = newkl;
        trackpoint* newtpl = new trackpoint[tc];
        for(int i = 0; i < tc; i++){
            newtpl[i].h = tpl[tc-1-i].h;
            newtpl[i].d = tpl[tc-1].d - tpl[tc-1-i].d;
        }
        delete tpl;
        tpl = newtpl;
    }
}
void Track::adapt_brect(double* latmin, double* latmax,
                     double* lonmin, double* lonmax){
    if(kl != NULL)
        for(int i = 0; i < kc; i++){
            if(kl[i].k->lat > *latmax) *latmax = kl[i].k->lat;
            if(kl[i].k->lat < *latmin) *latmin = kl[i].k->lat;
            if(kl[i].k->lon > *lonmax) *lonmax = kl[i].k->lon;
            if(kl[i].k->lon < *lonmin) *lonmin = kl[i].k->lon;
        }
}
void Track::get_brect(double* latmin, double* latmax,
                      double* lonmin, double* lonmax){
    *latmax =  -90;
    *latmin =   90;
    *lonmax = -180;
    *lonmin =  180;
    adapt_brect(latmin,latmax,lonmin,lonmax);
}
int Track::owns(KOO* k){
    for(int i = 0; i < kc; i++)
        if(kl[i].k == k)
            return 1;
    return 0;
}
void Track::reset_markers(){
    if(kl != NULL){
        for(int i = 0; i < kc; i++)
            kl[i].marked = 0;
        kl[0].marked = kl[kc-1].marked = 1;
    }
}
short Track::toggle_marker(KOO* k){
    if(kl != NULL){
        int ci = 0;
        while(kl[ci].k != k && ci < kc)
            ci++;
        /*falls gefunden umschalten*/
        if(ci < kc-1 && ci > 0){
            if(kl[ci].marked == 0)
                kl[ci].marked = 1;
            else
                kl[ci].marked = 0;
            return 1;
        }
        else
            return 0;
    }
    return 0;
}
void Track::get_anchors(float d, KOO** kfrom, KOO** kto){
    *kfrom = NULL;
    *kto = NULL;
    if(kl != NULL){
        if(d <= 0)
            *kto = kl[0].k;
        if(d >= kl->prev->d)
            *kfrom = kl[kc-1].k;
        if(d > 0 && d < kl[kc-1].d){
            int ci = 1;
            while(kl[ci].d < d || kl[ci].marked == 0){
                if(kl[ci].marked) *kfrom = kl[ci].k;
                ci++;
            }
            *kto = kl[ci].k;
        }
    }
}
short Track::found_anchors(double clickedlat, double clickedlon,
                           float maxd, KOO** kfrom, KOO** kto){
    /*naechsten Anker raussuchen*/
    float dmax = maxd;
    int clicki = -1;
    for(int i = 0; i < kc; i++)
        if(   kl[i].marked
           && distance(clickedlat,clickedlon,
                       kl[i].k->lat,kl[i].k->lon) < dmax){
            /*ein Anker innerhalb der Maximaldistanz dmax wurde gefunden*/
            clicki = i;
            dmax = distance(clickedlat,clickedlon,
                            kl[i].k->lat,kl[i].k->lon);
        }

    if(clicki >= 0){
        kl[clicki].marked = 0;
        /*ein Anker wurde gefunden*/
        /*suche nachfolgenden Anker*/
        int ci = clicki;
        while(ci < kc-1 && !kl[ci].marked)
            ci++;
        if(ci != clicki)
            *kto = kl[ci].k;
        else
            *kto = NULL;
        /*suche vorhergehenden Anker*/
        ci = clicki;
        while(ci > 0 && !kl[ci].marked)
            ci--;
        if(ci != clicki)
            *kfrom = kl[ci].k;
        else
            *kfrom = NULL;
        kl[clicki].marked = 1;
        return 1;
    }
    else
        return 0;
}
short Track::next_cross(double clickedlat, double clickedlon,
                         KOO** kdot, float maxd){
    *kdot = NULL;
    short marked;
    /*naechsten Anker raussuchen*/
    float dmax = maxd;
    for(int i = 0; i < kc; i++)
        if(   kl[i].k->status == 2
           && distance(clickedlat,clickedlon,
                       kl[i].k->lat,kl[i].k->lon) < dmax){
            /*ein Anker innerhalb der Maximaldistanz dmax wurde gefunden*/
            *kdot = kl[i].k;
            if(kl[i].marked) marked = 1;
            else          marked = 0;
            dmax = distance(clickedlat,clickedlon,
                            kl[i].k->lat,kl[i].k->lon);
        }

    if(*kdot != NULL){
        if(marked)  return 2;
        else        return 1;
    }
    else
        return 0;
}
float Track::get_bend(){
    if(kl != NULL){
        float cbend = 0;
        float ang1, ang2, tbend;
        float d = 0;
        float result = 0;
        for(int i = 0; i < kc-2; i++){
            d = d + distance(kl[i].k->lat,kl[i].k->lon,kl[i+1].k->lat,kl[i+1].k->lon);
            ang1 = atan2(kl[i+1].k->lat-kl[i].k->lat,
                         kl[i+1].k->lon-kl[i].k->lon);
            ang2 = atan2(kl[i+2].k->lat-kl[i+1].k->lat,
                         kl[i+2].k->lon-kl[i+1].k->lon);
            tbend = ang2 - ang1;
            if(tbend < -M_PI) tbend = tbend + 2*M_PI;
            if(tbend >  M_PI) tbend = tbend - 2*M_PI;
            if(tbend *cbend < 0){
                result = result + cbend*cbend/M_PI/M_PI;
                cbend = tbend;
            }
            else{
                cbend = cbend + tbend;
            }
        }
        result = result + cbend*cbend/M_PI/M_PI;
        return result;
    }
    else
        return 0;
}
void Track::to_binary_KOO(char* filename){
    FILE* f = fopen(filename,"wb");
    fwrite(&kc,sizeof(kc),1,f);
    float floatbuf;
    for(int i = 0; i < kc; i++){
        floatbuf = float(kl[i].k->lat);
        fwrite(&(floatbuf),sizeof(float),1,f);
        floatbuf = float(kl[i].k->lon);
        fwrite(&(floatbuf),sizeof(float),1,f);
    }
    fclose(f);
}
void Track::to_gpx(char* filename){
    FILE* f = fopen(filename,"w");
    fprintf(f,"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
    fprintf(f,"<gpx \nversion=\"1.0\" creator=\"GPSBabel - http://www.gpsbabel.org\"");
    fprintf(f,"\nxmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
    fprintf(f,"\nxmlns=\"http://www.topografix.com/GPX/1/0\"");
    fprintf(f,"\nxsi:schemaLocation=\"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd\">");
    fprintf(f,"\n<time>2010-03-14T06:49:54Z</time>\n");
    double minlat,minlon, maxlat, maxlon;
    get_brect(&minlat,&maxlat,&minlon,&maxlon);
    fprintf(f,"<bounds minlat=\"");
    fprintf(f,"%f\" minlon =\"%f\" maxlat=\"%f\" maxlon=\"%f\" />"
            ,minlat,minlon,maxlat,maxlon);

    fprintf(f,"<trkseg>\n");
    for(int i = 0; i < kc; i++)
        fprintf(f,"\n<trkpt lat=\"%f\" lon=\"%f\">\n<ele>0.000000</ele>\n</trkpt>"
                 ,kl[i].k->lat,kl[i].k->lon);

    fprintf(f,"</trkseg>\n");
    fprintf(f,"</trk>\n</gpx>");
    fclose(f);
}
KOO Track::get_firstKOO(){
    if(kl != NULL)
        return *(kl[0].k);
    else{
        KOO k; k.lat = 0; k.lon = 0;
        return k;
    }
}

KOO Track::get_lastKOO(){
    if(kl != NULL)
        return *(kl[kc-1].k);
    else{
        KOO k; k.lat = 0; k.lon = 0;
        return k;
    }
}