source: proto/gml2svg/C/xerces/gml2svg.cpp @ 3359

Last change on this file since 3359 was 3241, checked in by ksherdy, 6 years ago

Del readme.

File size: 8.8 KB
Line 
1/*
2    gml2svg.cpp
3    Copyright (C) 2007, 2008, 2011, 2012
4    Ken Herdy
5    Version 0.9
6    Licensed to the public under the Open Software License 3.0.
7*/
8
9#include <xercesc/sax2/SAX2XMLReader.hpp>
10#include <xercesc/sax2/XMLReaderFactory.hpp>
11#include <xercesc/sax2/DefaultHandler.hpp>
12#include <xercesc/util/XMLString.hpp>
13#include <sstream>
14#include <perfsec.h>
15
16
17#include "gml2svg_handler.hpp"
18#include <gml2svg/vancouver_constants.h>
19#include <gml2svg/util.h>
20#include <sys/stat.h>
21#include <stdio.h>
22#include <float.h>
23#include <unistd.h>
24#include <errno.h>
25#include <linux/errno.h>
26extern int errno;
27
28#include <iostream>
29using namespace std;
30
31#ifdef BUFFER_PROFILING
32    BOM_Table * parser_timer;
33#elif PAPI
34    #include <cc.h>
35    #include <cc.cxx>
36    CC * timer;
37#else
38    void * parser_timer;
39#endif
40
41const int ITERATIONS = 1;
42const bool SHOW_ITERATION_RESULTS = false;
43
44XERCES_CPP_NAMESPACE_USE
45
46int main (int argc, char* argv[]) {
47
48//       PERF_SEC_BIND(3);
49
50        char * gml_src_dir_path = NULL;
51        char * svg_dest_dir_path = NULL;
52
53        int papi_event;
54
55        if (argc > 2)
56        {
57                /* test GML src dir ends with FILE_SEPARATOR and exists */
58                gml_src_dir_path = new char[strlen(argv[1]) +1 +1];
59                if(gml_src_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
60                strcpy(gml_src_dir_path,argv[1]);
61
62                if(gml_src_dir_path[strlen(gml_src_dir_path)-1] != FILE_SEPARATOR)
63                {
64                        gml_src_dir_path[strlen(gml_src_dir_path)] = FILE_SEPARATOR;
65                        gml_src_dir_path[strlen(gml_src_dir_path)] = '\0';
66                        if(!fopen(gml_src_dir_path,"r"))
67                        {
68                                fprintf(stderr, "GML source directory '%s' does not exist. Terminating the process ...\n", gml_src_dir_path); exit(-1);
69                        }
70                }
71
72                /* test SVG dest dir ends with FILE_SEPARATOR and exists */
73                svg_dest_dir_path = new char[strlen(argv[2]) +1 +1];
74                if(svg_dest_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
75                strcpy(svg_dest_dir_path,argv[2]);
76
77                if(svg_dest_dir_path[strlen(svg_dest_dir_path)-1] != FILE_SEPARATOR)
78                {
79                        svg_dest_dir_path[strlen(svg_dest_dir_path)] = FILE_SEPARATOR;
80                        svg_dest_dir_path[strlen(svg_dest_dir_path)] = '\0';
81                        if(!fopen(svg_dest_dir_path,"r"))
82                        {
83                                errno = 0;
84                                static mode_t mode = 0755;
85                                if(mkdir(svg_dest_dir_path,mode)<0)
86                                {
87                                        fprintf(stderr,"Cannot create SVG destination directory '%s'. Terminating the proecess ...\n",svg_dest_dir_path);
88                                }
89                        }
90                }
91               
92                #if defined (PAPI) 
93
94                if(argc == 4) {
95                        /* Convert hex string PAPI code to unsigned integer */ 
96                        unsigned int temp;
97                        std::stringstream ss;
98                        ss << std::hex << argv[3];
99                        ss >> temp;
100                        papi_event = temp;
101                }
102                else
103                {
104                        fprintf(stderr, "gml2svg <GML SRC DIR> <SVG DEST DIR> [PAPI_EVENT]\n"); exit(-1);
105                }
106
107                #endif
108
109        }
110        else
111        {
112                fprintf(stderr, "gml2svg <GML SRC DIR> <SVG DEST DIR> [PAPI_EVENT]\n"); exit(-1);
113        }
114
115        /* Initialize parser */
116        try {
117            XMLPlatformUtils::Initialize();
118        }
119        catch (const XMLException& toCatch) {
120
121            char* message = XMLString::transcode(toCatch.getMessage());
122            cout << "Error during initialization! :\n";
123            cout << "Exception message is: \n"
124                 << message << "\n";
125            XMLString::release(&message);
126            return 1;
127        }
128
129        /* allocate memory for gml, svg, csv file paths */
130        char * gml_filename = new char[strlen(gml_src_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(GML_DOT_EXT) +1];
131        char * svg_filename = new char[strlen(svg_dest_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(SVG_DOT_EXT) +1];
132        if(gml_filename == NULL ||  svg_filename == NULL) {fprintf(stderr, "function: main, out of memory. Terminating the process ...\n"); exit(-1);}
133
134        #if defined (PAPI) 
135                #define PAPI_EVENTS_COUNT 1
136                // int papi_event = PAPI_TOT_CYC;
137                int PAPI_EVENTS[1]; 
138                PAPI_EVENTS[0] = papi_event;   
139        #endif
140       
141        PERF_SEC_INIT(parser_timer);
142
143        string cmd_line;
144        for(int i=0;i<argc;i++)
145        {
146                cmd_line += argv[i];
147                cmd_line += " ";
148        }
149
150//      parser_timer->set_cmd(cmd_line);
151
152        int layer_count = FEATURE_LAYER_COUNT; /* ignore point geometries */
153
154        /* Output IO Type */
155        #if !defined(NAIVE_FORMATTED_IO) && !defined(FORMATTED_IO) && !defined(MEMCPY_IO)
156                fprintf(stderr, "IO preprocessor directive '%s' not defined. Terminating the process ...", "NAIVE_FORMATTED_IO | FORMATTERD_IO | MEMCPY_IO"); exit(-1);
157        #endif
158
159        #if defined(NAIVE_FORMATTED_IO)
160                fprintf(stdout,"IO = NAIVE_FORMATTED_IO\n");
161                PERF_SEC_ADD_PARAM(parser_timer, "IO", "NAIVE_FORMATTED_IO");
162        #elif defined(FORMATTED_IO)
163                fprintf(stdout,"IO = FORMATTED_IO\n");
164                PERF_SEC_ADD_PARAM(parser_timer, "IO", "FORMATTED_IO");
165        #elif defined(MEMCPY_IO)
166                fprintf(stdout,"IO = MEMCPY_IO\n");
167                PERF_SEC_ADD_PARAM(parser_timer, "IO", "MEMCPY_IO");
168        #endif
169
170#define WORLD2SCREEN
171        /* Output World2Screen information */
172        #if defined(WORLD2SCREEN)
173                fprintf(stdout, "World2Screen transformations = true.\n");
174                PERF_SEC_ADD_PARAM(parser_timer, "WORLD2SCREEN", "true");
175        #else
176                fprintf(stdout, "World2Screen transformations = false.\n");
177                PERF_SEC_ADD_PARAM(parser_timer, "WORLD2SCREEN", "false");
178        #endif
179
180        /* Set up Timing */
181        #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO)
182                FILE * stats_file;
183                struct stat fileinfo;
184        #endif
185
186        SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
187        parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes,true);   // Report the original prefixed names and attributes used for Namespace declarations.
188        parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);                 // Perform Namespace processing.
189        parser->setFeature(XMLUni::fgSAX2CoreValidation, false);                // Do not report validation errors.
190
191        GML2SVGHandler* defaultHandler = new GML2SVGHandler();
192        parser->setContentHandler(defaultHandler);
193        parser->setErrorHandler(defaultHandler);
194
195        FILE * out_file = NULL;
196        char * out_buf = NULL;
197
198        for(int i=0;i<layer_count;i++)
199        //for(int i=0;i<1;i++)
200        {               
201        //      int i = 27;             
202
203                /* Set layer specific GML and SVG file paths */
204                strcpy(gml_filename, gml_src_dir_path);
205                strcat(gml_filename, feature_layers[i].lname);
206                strcat(gml_filename,GML_DOT_EXT);
207
208                fprintf(stdout, "Processing GML file: %s.\n", gml_filename);
209                fflush(stdout);
210
211                strcpy(svg_filename,svg_dest_dir_path);
212                strcat(svg_filename,feature_layers[i].lname);
213                strcat(svg_filename,SVG_DOT_EXT);
214
215    PERF_SEC_ADD_PARAM(parser_timer, "Layer", feature_layers[i].lname);
216
217                if(!(out_file = fopen(svg_filename, "w")))
218                {
219                        fprintf(stderr, "Failed to open '%s' for output.  Terminating the process ...\n", svg_filename); exit(-1);
220                }
221
222                for(int j=0;j<ITERATIONS;j++)
223                {
224                        PERF_SEC_START(timer);
225
226                        /* parse */
227                        try {
228
229                                /* Initialize output buffer */
230                                #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO) // BUFFERED_IO
231                                    /* allocate file sized output buffer */
232
233                                        stats_file = fopen(gml_filename, "rb");
234                                        if(stats_file == NULL) {
235                                                fprintf(stderr, "Cannot open '%s'. Terminating the process ...\n", gml_filename); exit(-1);
236                                        }
237
238                                        if(fstat(fileno(stats_file), &fileinfo)!=0) {
239                                                fprintf(stderr, "Error: cannot fstat '%s'. Terminating the process ...\n", gml_filename); exit(-1);
240                                        }
241                                        /* allocate global output buffer memory */
242                                        out_buf = new char[(fileinfo.st_size * 2)];
243                                        fclose(stats_file);
244                                #endif
245
246                                defaultHandler->setOutputBuffer(out_buf);
247
248                                defaultHandler->setParameters ( SCREEN_WIDTH,
249                                                        SCREEN_HEIGHT,
250                                                        BBOX,
251                                                        feature_layers[i].lname,
252                                                        FEATURE_ID_LNAME,
253                                                        feature_layers[i].lgeometry,
254                                                        feature_layers[i].style);
255
256                                parser->parse(gml_filename);
257
258                        }
259                        catch (const XMLException& toCatch) {
260                            char* message = XMLString::transcode(toCatch.getMessage());
261                            cerr << "Exception: " << message << ".\n";
262                            XMLString::release(&message);
263                            return -1;
264                        }
265                        catch (const SAXParseException& toCatch) {
266                            char* message = XMLString::transcode(toCatch.getMessage());
267                            cerr << "Exception: " << message << ".\n";
268                            XMLString::release(&message);
269                            return -1;
270                        }
271                        catch (...) {
272                                cerr << "Exception: Unhandled exception.\n";
273                            return -1;
274                        }
275
276                        PERF_SEC_END(parser_timer, fileinfo.st_size);
277
278                        if(SHOW_ITERATION_RESULTS)
279                        {
280                                fprintf(stdout, "'%s' complete.\n\n",feature_layers[i].lname);
281                        }
282
283                }
284
285                /* Write SVG file */
286                #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO) // BUFFERED_IO
287
288                        fprintf(out_file, "%s", out_buf);
289                        fflush(out_file);
290
291                        if(!out_buf)
292                        {
293                                delete [] out_buf;
294                                out_buf = NULL;
295                        }
296       
297                #endif
298
299                fclose(out_file);
300
301                memset(gml_filename,'\0',strlen(gml_filename));
302                memset(svg_filename,'\0',strlen(svg_filename));
303
304        }
305
306        fprintf(stdout,"\nProcessing complete.\n\n");
307
308        //PERF_SEC_DUMP(timer);
309       
310        PERF_SEC_WRITE(timer);
311
312        if(gml_src_dir_path) {delete [] gml_src_dir_path;}
313        if(gml_filename) {delete [] gml_filename;}
314        if(svg_dest_dir_path) {delete [] svg_dest_dir_path;}
315        if(svg_filename) {delete [] svg_filename;}
316
317        delete parser;
318        delete defaultHandler;
319
320        XMLPlatformUtils::Terminate();
321        return 0;
322}
323
Note: See TracBrowser for help on using the repository browser.