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

Last change on this file since 1727 was 1727, checked in by ksherdy, 8 years ago

Updated Xerces GML2SVG sample application.

File size: 11.0 KB
Line 
1/*
2    gml2svg.cpp
3    Copyright (C) 2007, 2008, 2011 Ken Herdy
4    Version 0.9
5    Licensed to the public under the Open Software License 3.0.
6*/
7
8#include <xercesc/sax2/SAX2XMLReader.hpp>
9#include <xercesc/sax2/XMLReaderFactory.hpp>
10#include <xercesc/sax2/DefaultHandler.hpp>
11#include <xercesc/util/XMLString.hpp>
12
13#include "gml2svg_handler.hpp"
14#include <gml2svg/vancouver_constants.h>
15#include <gml2svg/util.h>
16#include <sys/stat.h>
17#include <stdio.h>
18#include <float.h>
19#include <unistd.h>
20#include <errno.h>
21#include <linux/errno.h>
22extern int errno;
23
24#include <iostream>
25using namespace std;
26
27#if defined(PAPI)
28        #include <cc.h>
29        CC * code_clocker;
30#endif
31
32const int ITERATIONS = 1;
33const bool SHOW_ITERATION_RESULTS = false;
34
35XERCES_CPP_NAMESPACE_USE
36
37int main (int argc, char* argv[]) {
38
39        char * gml_src_dir_path = NULL;
40        char * svg_dest_dir_path = NULL;
41
42        if (argc > 2)
43        {
44                /* test GML src dir ends with FILE_SEPARATOR and exists */
45                gml_src_dir_path = new char[strlen(argv[1]) +1 +1];
46                if(gml_src_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
47                strcpy(gml_src_dir_path,argv[1]);
48
49                if(gml_src_dir_path[strlen(gml_src_dir_path)] != FILE_SEPARATOR)
50                {
51                        gml_src_dir_path[strlen(gml_src_dir_path)] = FILE_SEPARATOR;
52                        gml_src_dir_path[strlen(gml_src_dir_path)+1] = '\0';
53                        if(!fopen(gml_src_dir_path,"r"))
54                        {
55                                fprintf(stderr, "GML source directory '%s' does not exist. Terminating the process ...\n", gml_src_dir_path); exit(-1);
56                        }
57                }
58
59                /* test SVG dest dir ends with FILE_SEPARATOR and exists */
60                svg_dest_dir_path = new char[strlen(argv[2]) +1 +1];
61                if(svg_dest_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
62                strcpy(svg_dest_dir_path,argv[2]);
63
64                if(svg_dest_dir_path[strlen(svg_dest_dir_path)] != FILE_SEPARATOR)
65                {
66                        svg_dest_dir_path[strlen(svg_dest_dir_path)] = FILE_SEPARATOR;
67                        svg_dest_dir_path[strlen(svg_dest_dir_path)+1] = '\0';
68                        if(!fopen(svg_dest_dir_path,"r"))
69                        {
70                                errno = 0;
71                                static mode_t mode = 0755;
72                                if(mkdir(svg_dest_dir_path,mode)<0)
73                                {
74                                        fprintf(stderr,"Cannot create SVG destination directory '%s'. Terminating the proecess ...\n",svg_dest_dir_path);
75                                }
76                        }
77                }
78        }
79        else
80        {
81                fprintf(stderr, "gml2svg <GML SRC DIR> <SVG DEST DIR>\n"); exit(-1);
82        }
83
84        /* Initialize parser */
85        try {
86            XMLPlatformUtils::Initialize();
87        }
88        catch (const XMLException& toCatch) {
89
90                char* message = XMLString::transcode(toCatch.getMessage());
91            cout << "Error during initialization! :\n";
92            cout << "Exception message is: \n"
93                 << message << "\n";
94            XMLString::release(&message);
95            return 1;
96        }
97
98        /* allocate memory for gml, svg, csv file paths */
99        char * gml_filename = new char[strlen(gml_src_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(GML_DOT_EXT) +1];
100        char * svg_filename = new char[strlen(svg_dest_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(SVG_DOT_EXT) +1];
101        if(gml_filename == NULL ||  svg_filename == NULL) {fprintf(stderr, "function: main, out of memory. Terminating the process ...\n"); exit(-1);}
102
103        #if defined(SYSTEM_TIME)
104                char * csv_filename = new char[strlen(svg_dest_dir_path) + strlen("yyyy-mm-ddThh-mm-ss") + strlen(CSV_DOT_EXT) + 1];
105                char * csv_basename = new char[strlen("yyyy-mm-ddThh-mm-ss") +1];
106                if(csv_filename == NULL || csv_basename == NULL) {fprintf(stderr, "function: main, out of memory. Terminating the process ...\n"); exit(-1);}
107
108                /* create csv file */
109                strcpy(csv_filename,svg_dest_dir_path);
110                csv_basename = create_timestamp_filename();
111                strcat(csv_filename,csv_basename);
112                strcat(csv_filename,CSV_DOT_EXT);
113
114                FILE * csv_out;
115                if(!(csv_out = fopen(csv_filename, "w")))
116                {
117                        fprintf(stderr, "Failed to open CSV file '%s' for output. Terminating the process ...\n", csv_filename); exit(-1);
118                }
119        #endif
120
121        #if defined(PAPI)
122
123                        #define NUM_EVENTS 1
124                        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
125
126                        int cal_size = 5;
127                        code_clocker = new CC(Events,NUM_EVENTS,cal_size);
128
129                        string cmd_line;
130                        for(int i=0;i<argc;i++)
131                        {
132                                cmd_line += argv[i];
133                                cmd_line += " ";
134                        }
135                        code_clocker->set_cmd(cmd_line);
136        #endif
137
138        int layer_count = NUM_FEATURE_COLLECTIONS; /* ignore point geometries */
139
140        fprintf(stdout, "GML layers ...\n\n");
141        char * layers = layers_2_string(FEATURE_LNAMES, layer_count);
142        fprintf(stdout, "%s\n\n",layers);
143
144        #if defined(SYSTEM_TIME)
145                fprintf(csv_out,"%s, \n", "Xerces C (SAX)");
146        #endif
147
148        #if defined(PAPI)
149                code_clocker->set_param("Parser", "Xerces C (SAX)");
150        #endif
151
152        /* Output IO Type */
153        #if !defined(NAIVE_FORMATTED_IO) && !defined(FORMATTED_IO) && !defined(MEMCPY_IO)
154                fprintf(stderr, "IO preprocessor directive '%s' not defined. Terminating the process ...", "NAIVE_FORMATTED_IO | FORMATTERD_IO | MEMCPY_IO"); exit(-1);
155        #endif
156
157        #if defined(NAIVE_FORMATTED_IO)
158                fprintf(stdout,"IO = NAIVE_FORMATTED_IO\n");
159
160                #if defined(SYSTEM_TIME)
161                        fprintf(csv_out,"\n%s,%s", "IO", "NAIVE_FORMATTED_IO");
162                #endif
163
164                #if defined(PAPI)
165                        code_clocker->set_param("IO", "NAIVE_FORMATTED_IO");
166                #endif
167
168        #elif defined(FORMATTED_IO)
169                fprintf(stdout,"IO = FORMATTED_IO\n");
170
171                #if defined(SYSTEM_TIME)
172                        fprintf(csv_out,"\n%s,%s", "IO", "FORMATTED_IO");
173                #endif
174
175                #if defined(PAPI)
176                        code_clocker->set_param("IO", "FORMATTED_IO");
177                #endif
178
179        #elif defined(MEMCPY_IO)
180                fprintf(stdout,"IO = MEMCPY_IO\n");
181
182                #if defined(SYSTEM_TIME)
183                        fprintf(csv_out,"\n%s,%s", "IO", "MEMCPY_IO");
184                #endif
185
186                #if defined(PAPI)
187                        code_clocker->set_param("IO", "MEMCPY_IO");
188                #endif
189
190        #endif
191
192        /* Output World2Screen information */
193        #if defined(WORLD2SCREEN)
194                #if defined(SYSTEM_TIME)
195                        fprintf(csv_out,"\n%s,%s", "WORLD2SCREEN", "true");
196                #endif
197
198                #if defined(PAPI)
199                        code_clocker->set_param("WORLD2SCREEN", "true");
200                #endif
201
202                fprintf(stdout, "World2Screen transformations = true.\n");
203        #else
204                #if defined(SYSTEM_TIME)
205                        fprintf(csv_out,"\n%s,%s", WORLD2SCREEN_NAME, "false");
206                #endif
207
208                #if defined(PAPI)
209                        code_clocker->set_param("WORLD2SCREEN", "false");
210                #endif
211
212                fprintf(stdout, "World2Screen transformations = false.\n");
213        #endif
214
215        /* Set up Timing */
216        #if defined(SYSTEM_TIME)
217                fprintf(csv_out,"\n\n%s,%s", "Layers", "Duration (ms)");
218                fprintf(csv_out,"\n%s,%s","GML Directory",gml_src_dir_path);
219
220                clock_t start;
221                double duration = 0;
222                double clocks_per_sec = (double)CLOCKS_PER_SEC;
223        #endif
224
225        #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO)
226                FILE * stats_file;
227                struct stat fileinfo;
228        #endif
229
230        SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
231        parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes,true);   // Report the original prefixed names and attributes used for Namespace declarations.
232        parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);                 // Perform Namespace processing.
233        parser->setFeature(XMLUni::fgSAX2CoreValidation, false);                // Do not report validation errors.
234
235        GML2SVGHandler* defaultHandler = new GML2SVGHandler();
236        parser->setContentHandler(defaultHandler);
237        parser->setErrorHandler(defaultHandler);
238
239        FILE * out_file = NULL;
240        char * out_buf = NULL;
241
242        fprintf(stdout, "\nProcessing layers ...\n\n");
243        for(int i=0;i<layer_count;i++)
244        //for(int i=0;i<1;i++)
245        {
246                /* Set layer specific GML and SVG file paths */
247                strcpy(gml_filename,gml_src_dir_path);
248                strcat(gml_filename,FEATURE_LNAMES[i]);
249                strcat(gml_filename,GML_DOT_EXT);
250
251                strcpy(svg_filename,svg_dest_dir_path);
252                strcat(svg_filename,FEATURE_LNAMES[i]);
253                strcat(svg_filename,SVG_DOT_EXT);
254
255                #if defined(SYSTEM_TIME)
256                        fprintf(csv_out,"\n%s",FEATURE_LNAMES[i]);
257                #endif
258
259                #if defined(PAPI)
260                        code_clocker->set_param("Layer", FEATURE_LNAMES[i]);
261                #endif
262
263                if(!(out_file = fopen(svg_filename, "w")))
264                {
265                        fprintf(stderr, "Failed to open '%s' for output.  Terminating the process ...\n", svg_filename); exit(-1);
266                }
267
268                for(int j=0;j<ITERATIONS;j++)
269                {
270                        //TODO - READ FILE INTO MEMORY
271
272                        #if defined(SYSTEM_TIME)
273                                start = clock();
274                        #endif
275
276                        #if defined(PAPI)
277                                code_clocker->start_interval();
278                        #endif
279
280                        /* parse */
281                        try {
282
283                                /* Initialize output buffer */
284                                #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO) // BUFFERED_IO
285                                    /* allocate file sized output buffer */
286                                        stats_file = fopen(gml_filename, "rb");
287                                        if(stats_file == NULL) {
288                                                fprintf(stderr, "Cannot open '%s'. Terminating the process ...\n", gml_filename); exit(-1);
289                                        }
290
291                                        if(fstat(fileno(stats_file), &fileinfo)!=0) {
292                                                fprintf(stderr, "Error: cannot fstat '%s'. Terminating the process ...\n", gml_filename); exit(-1);
293                                        }
294                                        /* allocate global output buffer memory */
295                                        out_buf = new char[(fileinfo.st_size * 2)];
296                                        fclose(stats_file);
297
298                                // BUFFERED_IO #elif defined(MEMCPY_IO) ::_out_buf_crt = parser->GetOutputBufferPtr();
299                                #endif
300
301                            defaultHandler->setOutputBuffer(out_buf);
302                                defaultHandler->setParameters ( SCREEN_WIDTH,
303                                                                                SCREEN_HEIGHT,
304                                                                                BBOX,
305                                                                                FEATURE_LNAMES[i],
306                                                                                FEATURE_ID_LNAME,
307                                                                                FEATURE_LGEOMETRY[i],
308                                                                                FEATURE_STYLES[i]);
309                                parser->parse(gml_filename);
310                        }
311                        catch (const XMLException& toCatch) {
312                            char* message = XMLString::transcode(toCatch.getMessage());
313                            cerr << "Exception: " << message << ".\n";
314                            XMLString::release(&message);
315                            return -1;
316                        }
317                        catch (const SAXParseException& toCatch) {
318                            char* message = XMLString::transcode(toCatch.getMessage());
319                            cerr << "Exception: " << message << ".\n";
320                            XMLString::release(&message);
321                            return -1;
322                        }
323                        catch (...) {
324                                cerr << "Exception: Unhandled exception.\n";
325                            return -1;
326                        }
327
328                        #if defined(SYSTEM_TIME)
329                                duration = ((clock() - start)/clocks_per_sec) * 1000;
330                                fprintf(csv_out,",%5.10f", duration);
331
332                                if(SHOW_ITERATION_RESULTS)
333                                {
334                                        fprintf(stdout, "'%s' interval time ~%5.10f ms.\n",FEATURE_LNAMES[i], duration);
335                                }
336                        #endif
337
338                        #if defined(PAPI)
339                                code_clocker->end_interval(0);
340
341                                if(SHOW_ITERATION_RESULTS)
342                                {
343                                        fprintf(stdout, "'%s' complete.\n",FEATURE_LNAMES[i]);
344                                }
345                        #endif
346
347                }
348
349                /* Write SVG file */
350                #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO) // BUFFERED_IO
351                        fprintf(out_file, "%s", out_buf);
352                        fflush(out_file);
353
354                        if(!out_buf)
355                        {
356                                delete [] out_buf;
357                                out_buf = NULL;
358                        }
359                #endif
360
361                fclose(out_file);
362
363                memset(gml_filename,'\0',strlen(gml_filename));
364                memset(svg_filename,'\0',strlen(svg_filename));
365
366                #if defined(SYSTEM_TIME)
367                        memset(csv_filename,'\0',strlen(csv_filename));
368                #endif
369        }
370
371        fprintf(stdout,"\nProcessing complete.\n");
372
373        #if defined(PAPI)
374                code_clocker->display_system_info();
375                code_clocker->display_raw_event_data();
376                code_clocker->write_xml_file();
377        #endif
378
379        if(layers) {delete layers;}
380        if(gml_src_dir_path) {delete [] gml_src_dir_path;}
381        if(gml_filename) {delete [] gml_filename;}
382        if(svg_dest_dir_path) {delete [] svg_dest_dir_path;}
383        if(svg_filename) {delete [] svg_filename;}
384
385        #if defined(SYSTEM_TIME)
386                fclose(csv_out);
387                if(csv_filename) {delete [] csv_filename;}
388                if(csv_basename) {delete [] csv_basename;}
389        #endif
390
391    delete parser;
392        delete defaultHandler;
393
394        XMLPlatformUtils::Terminate();
395        return 0;
396}
Note: See TracBrowser for help on using the repository browser.