gpx2navit_txt.h

Go to the documentation of this file.

#ifndef GPX2SHP_H_INCLUDED
#define GPX2SHP_H_INCLUDED

#define PROG gpx2navit_txt
#define FILENAMELENGTH 255      /* 255 is max length for dbf string column */
#define COMMENTLENGTH 255       /* 255 is max length for dbf string column */
#define NAMELENGTH 32
#define TIMELENGTH 32
#define TYPELENGTH 16
#define BUFFSIZE 8192
#define DATABUFSIZE 16
#define failToWriteAttr(S, T) failToWriteAttrRep((S), (T),__FILE__, __LINE__ )

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <unistd.h>
#include <libgen.h>
#include <getopt.h>
#include <time.h>
#include <assert.h>
#include <expat.h>
#include "errorcode.h"
//#include "shapefil.h"


#define DEBUG 0

typedef struct parent {
    char *name;         
    struct parent *parentptr;
} parent;

typedef struct g2scolumns {
    int name;
    int cmt;
    int desc;
    int src;
    int link;
    int type;
    int time;
    int number;
    int ele;
    int magvar;
    int geoidheight;
    int sym;
    int fix;
    int sat;
    int hdop;
    int vdop;
    int pdop;
    int ageofdgpsdata;
    int dgpsid;
    int length;
    int interval;
    int speed;
    int points;
    int gpxline;
} g2scolumns;

typedef struct pathattr {
    char name[NAMELENGTH];
    char cmt[COMMENTLENGTH];
    char desc[COMMENTLENGTH];
    char src[COMMENTLENGTH];
    char link[FILENAMELENGTH];
    int number;
    char type[TYPELENGTH];
    double length;
    double interval;
    double speed;
    /*
    double *x;
    double *y;
    double *z;
    */
    double *point;
    int count;
} pathattr;

typedef struct g2sattr {
    double lon;
    double lat;
    double minlon;
    double minlat;
    double maxlon;
    double maxlat;
    char name[NAMELENGTH];
    char cmt[COMMENTLENGTH];
    char desc[COMMENTLENGTH];
    char src[COMMENTLENGTH];
    char link[FILENAMELENGTH];
    char type[TYPELENGTH];
    char time[TIMELENGTH];
    int number;
    double ele;
    double magvar;
    double geoidheight;
    char sym[NAMELENGTH];
    char fix[NAMELENGTH];
    int sat;
    double hdop;
    double vdop;
    double pdop;
    double ageofdgpsdata;
    int dgpsid;
    char author[NAMELENGTH];
    char keywords[NAMELENGTH];
    char copyright[NAMELENGTH];
    int year;
    char license[NAMELENGTH];
} g2sattr;

typedef struct g2sstats {
        int trkpoints;  
        int trkcount;   
    double trklength;   
    int rtepoints;      
    int rtecount;       
    double rtelength;   
    int wptpoints;      
    int trkunconverted; 
    int rteunconverted; 
} g2sstats;

//typedef struct dbfhandles {
//    DBFHandle trk;    /** for track */
//    DBFHandle wpt;    /** for waypoint */
//    DBFHandle rte;    /** for route */
//    DBFHandle trk_edg;        /** for track each edge */
//    DBFHandle trk_pnt;        /** for track each point */
//    DBFHandle rte_edg;        /** for route each edge */
//    DBFHandle rte_pnt;        /** for route each point */
//} dbfhandles;

//typedef struct shphandles {
//    SHPHandle trk;    /** for track */
//    SHPHandle wpt;    /** for waypoint */
//    SHPHandle rte;    /** for route */
//    SHPHandle trk_edg;        /** for track each edge */
//    SHPHandle trk_pnt;        /** for track each point */
//    SHPHandle rte_edg;        /** for route each edge */
//    SHPHandle rte_pnt;        /** for route each point */
//} shphandles;

typedef struct g2sprop {
    int parseWpt;       
    int parseTrk;       
    int parseRte;       
    int is3d;           
    int isEdge;         
    int isPoint;        
    int isFast;         
    int needsStats;     
    int minpoints;      
    int minlength;      
    int mintime;        
    int verbose;        
    char *sourcefile;   
    char *output;       
    char *ellipsoid;    
    char *lengthUnit;   
    double length2meter;
    char *timeUnit;     
    double time2sec;    
    char *speedLengthUnit;
    double speed2meter; 
    char *speedTimeUnit;
    int speed2sec;      
    g2sstats *stats;    
    g2scolumns *cols;   
    int nospeedcheck;   
} g2sprop;

typedef struct parsedata {
    int depth;          
    char *databuf;      
    char *bufptr;       
    int failed;         
    int failedid;       
    XML_Parser parser;  
    parent *parent;     
    parent *current;    
    FILE *fp;           
//    shphandles *shps; /** .shp file cluster that is used in this program */
//    dbfhandles *dbfs; /** .dbf file cluster that is used in this program */
    g2sattr *attr;      
    pathattr *pattr;    
    g2sprop *prop;      
} parsedata;

/* utils.c */
void checkEllpsUnit(char *unit);
double checkLengthUnit(char *unit);
int checkTimeUnit(char *unit);
double getTimeInterval(char *_t, char *t);
double getSpeed(double length, double ti, double to_meter, int to_sec);
double getDistance(double _x, double _y, double x, double y);
//void closeShpFiles(shphandles * shps);
//void closeDbfFiles(dbfhandles * dbfs);
void *myMallocRep(size_t size, const char *fileName, int line);

/* misc.c */
void failToWriteAttrRep(int iShape, int col, char *file, int line);
void showStats(g2sprop * prop);
void wipePathAttr(pathattr * pattr);
pathattr *createPathAttr(void);
void wipeAttr(g2sattr * attr);
void setColsDefault(g2scolumns * cols);
g2scolumns *createCols(void);
g2sattr *createAttr(void);
g2sprop *createProp(void);
void closeProp(g2sprop * prop);
//shphandles *createShps(void);
//dbfhandles *createDbfs(void);
parsedata *createParsedata(XML_Parser parser, g2sprop * prop);
void closeParsedata(parsedata * pdata);

/* parser.c */
void parseMain(g2sprop * pr);

/* elementControl.c */
void startElementControl(parsedata * pdata, const char *element,
                         const char **attr);
void endElementControl(parsedata * pdata, const char *element);

/* setwpt.c */
void setWpt( parsedata * pdata);

/* setpath.c */
void initPathAttr(pathattr * pattr, g2sattr * attr);
void setPathInterval(parsedata *pdata);
void setPathData(pathattr * parrt, g2sattr * attr);
void setPath( parsedata * pdata);

/* setmetadata.c */
void setMetadata(parsedata * pdata);

#endif