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

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

Added gml2svg prototypes.

  • Property svn:executable set to *
File size: 11.1 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, "Missing command line arguments.");
82                fprintf(stderr, "Usage: %s <GML directory> <SVG directory>\n", argv[0]); exit(-1);
83        }
84
85        /* Initialize parser */
86        try {
87            XMLPlatformUtils::Initialize();
88        }
89        catch (const XMLException& toCatch) {
90
91                char* message = XMLString::transcode(toCatch.getMessage());
92            cout << "Error during initialization! :\n";
93            cout << "Exception message is: \n"
94                 << message << "\n";
95            XMLString::release(&message);
96            return 1;
97        }
98
99        /* allocate memory for gml, svg, csv file paths */
100        char * gml_filename = new char[strlen(gml_src_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(GML_DOT_EXT) +1];
101        char * svg_filename = new char[strlen(svg_dest_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(SVG_DOT_EXT) +1];
102        if(gml_filename == NULL ||  svg_filename == NULL) {fprintf(stderr, "function: main, out of memory. Terminating the process ...\n"); exit(-1);}
103
104        #if defined(SYSTEM_TIME)
105                char * csv_filename = new char[strlen(svg_dest_dir_path) + strlen("yyyy-mm-ddThh-mm-ss") + strlen(CSV_DOT_EXT) + 1];
106                char * csv_basename = new char[strlen("yyyy-mm-ddThh-mm-ss") +1];
107                if(csv_filename == NULL || csv_basename == NULL) {fprintf(stderr, "function: main, out of memory. Terminating the process ...\n"); exit(-1);}
108
109                /* create csv file */
110                strcpy(csv_filename,svg_dest_dir_path);
111                csv_basename = create_timestamp_filename();
112                strcat(csv_filename,csv_basename);
113                strcat(csv_filename,CSV_DOT_EXT);
114
115                FILE * csv_out;
116                if(!(csv_out = fopen(csv_filename, "w")))
117                {
118                        fprintf(stderr, "Failed to open CSV file '%s' for output. Terminating the process ...\n", csv_filename); exit(-1);
119                }
120        #endif
121
122        #if defined(PAPI)
123
124                        #define NUM_EVENTS 1
125                        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
126
127                        int cal_size = 5;
128                        code_clocker = new CC(Events,NUM_EVENTS,cal_size);
129
130                        string cmd_line;
131                        for(int i=0;i<argc;i++)
132                        {
133                                cmd_line += argv[i];
134                                cmd_line += " ";
135                        }
136                        code_clocker->set_cmd(cmd_line);
137        #endif
138
139        int layer_count = NUM_FEATURE_COLLECTIONS; /* ignore point geometries */
140
141        fprintf(stdout, "GML layers ...\n\n");
142        char * layers = layers_2_string(FEATURE_LNAMES, layer_count);
143        fprintf(stdout, "%s\n\n",layers);
144
145        #if defined(SYSTEM_TIME)
146                fprintf(csv_out,"%s, \n", "Xerces C (SAX)");
147        #endif
148
149        #if defined(PAPI)
150                code_clocker->set_param("Parser", "Xerces C (SAX)");
151        #endif
152
153        /* Output IO Type */
154        #if !defined(NAIVE_FORMATTED_IO) && !defined(FORMATTED_IO) && !defined(MEMCPY_IO)
155                fprintf(stderr, "IO preprocessor directive '%s' not defined. Terminating the process ...", "NAIVE_FORMATTED_IO | FORMATTERD_IO | MEMCPY_IO"); exit(-1);
156        #endif
157
158        #if defined(NAIVE_FORMATTED_IO)
159                fprintf(stdout,"IO = NAIVE_FORMATTED_IO\n");
160
161                #if defined(SYSTEM_TIME)
162                        fprintf(csv_out,"\n%s,%s", "IO", "NAIVE_FORMATTED_IO");
163                #endif
164
165                #if defined(PAPI)
166                        code_clocker->set_param("IO", "NAIVE_FORMATTED_IO");
167                #endif
168
169        #elif defined(FORMATTED_IO)
170                fprintf(stdout,"IO = FORMATTED_IO\n");
171
172                #if defined(SYSTEM_TIME)
173                        fprintf(csv_out,"\n%s,%s", "IO", "FORMATTED_IO");
174                #endif
175
176                #if defined(PAPI)
177                        code_clocker->set_param("IO", "FORMATTED_IO");
178                #endif
179
180        #elif defined(MEMCPY_IO)
181                fprintf(stdout,"IO = MEMCPY_IO\n");
182
183                #if defined(SYSTEM_TIME)
184                        fprintf(csv_out,"\n%s,%s", "IO", "MEMCPY_IO");
185                #endif
186
187                #if defined(PAPI)
188                        code_clocker->set_param("IO", "MEMCPY_IO");
189                #endif
190
191        #endif
192
193        /* Output World2Screen information */
194        #if defined(WORLD2SCREEN)
195                #if defined(SYSTEM_TIME)
196                        fprintf(csv_out,"\n%s,%s", "WORLD2SCREEN", "true");
197                #endif
198
199                #if defined(PAPI)
200                        code_clocker->set_param("WORLD2SCREEN", "true");
201                #endif
202
203                fprintf(stdout, "World2Screen transformations = true.\n");
204        #else
205                #if defined(SYSTEM_TIME)
206                        fprintf(csv_out,"\n%s,%s", WORLD2SCREEN_NAME, "false");
207                #endif
208
209                #if defined(PAPI)
210                        code_clocker->set_param("WORLD2SCREEN", "false");
211                #endif
212
213                fprintf(stdout, "World2Screen transformations = false.\n");
214        #endif
215
216        /* Set up Timing */
217        #if defined(SYSTEM_TIME)
218                fprintf(csv_out,"\n\n%s,%s", "Layers", "Duration (ms)");
219                fprintf(csv_out,"\n%s,%s","GML Directory",gml_src_dir_path);
220
221                clock_t start;
222                double duration = 0;
223                double clocks_per_sec = (double)CLOCKS_PER_SEC;
224        #endif
225
226        #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO)
227                FILE * stats_file;
228                struct stat fileinfo;
229        #endif
230
231        SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();
232        parser->setFeature(XMLUni::fgSAX2CoreNameSpacePrefixes,true);   // Report the original prefixed names and attributes used for Namespace declarations.
233        parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);                 // Perform Namespace processing.
234        parser->setFeature(XMLUni::fgSAX2CoreValidation, false);                // Do not report validation errors.
235
236        GML2SVGHandler* defaultHandler = new GML2SVGHandler();
237        parser->setContentHandler(defaultHandler);
238        parser->setErrorHandler(defaultHandler);
239
240        FILE * out_file = NULL;
241        char * out_buf = NULL;
242
243        fprintf(stdout, "\nProcessing layers ...\n\n");
244        for(int i=0;i<layer_count;i++)
245        //for(int i=0;i<1;i++)
246        {
247                /* Set layer specific GML and SVG file paths */
248                strcpy(gml_filename,gml_src_dir_path);
249                strcat(gml_filename,FEATURE_LNAMES[i]);
250                strcat(gml_filename,GML_DOT_EXT);
251
252                strcpy(svg_filename,svg_dest_dir_path);
253                strcat(svg_filename,FEATURE_LNAMES[i]);
254                strcat(svg_filename,SVG_DOT_EXT);
255
256                #if defined(SYSTEM_TIME)
257                        fprintf(csv_out,"\n%s",FEATURE_LNAMES[i]);
258                #endif
259
260                #if defined(PAPI)
261                        code_clocker->set_param("Layer", FEATURE_LNAMES[i]);
262                #endif
263
264                if(!(out_file = fopen(svg_filename, "w")))
265                {
266                        fprintf(stderr, "Failed to open '%s' for output.  Terminating the process ...\n", svg_filename); exit(-1);
267                }
268
269                for(int j=0;j<ITERATIONS;j++)
270                {
271                        //TODO - READ FILE INTO MEMORY
272
273                        #if defined(SYSTEM_TIME)
274                                start = clock();
275                        #endif
276
277                        #if defined(PAPI)
278                                code_clocker->start_interval();
279                        #endif
280
281                        /* parse */
282                        try {
283
284                                /* Initialize output buffer */
285                                #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO) // BUFFERED_IO
286                                    /* allocate file sized output buffer */
287                                        stats_file = fopen(gml_filename, "rb");
288                                        if(stats_file == NULL) {
289                                                fprintf(stderr, "Cannot open '%s'. Terminating the process ...\n", gml_filename); exit(-1);
290                                        }
291
292                                        if(fstat(fileno(stats_file), &fileinfo)!=0) {
293                                                fprintf(stderr, "Error: cannot fstat '%s'. Terminating the process ...\n", gml_filename); exit(-1);
294                                        }
295                                        /* allocate global output buffer memory */
296                                        out_buf = new char[(fileinfo.st_size * 2)];
297                                        fclose(stats_file);
298
299                                // BUFFERED_IO #elif defined(MEMCPY_IO) ::_out_buf_crt = parser->GetOutputBufferPtr();
300                                #endif
301
302                            defaultHandler->setOutputBuffer(out_buf);
303                                defaultHandler->setParameters ( SCREEN_WIDTH,
304                                                                                SCREEN_HEIGHT,
305                                                                                BBOX,
306                                                                                FEATURE_LNAMES[i],
307                                                                                FEATURE_ID_LNAME,
308                                                                                FEATURE_LGEOMETRY[i],
309                                                                                FEATURE_STYLES[i]);
310                                parser->parse(gml_filename);
311                        }
312                        catch (const XMLException& toCatch) {
313                            char* message = XMLString::transcode(toCatch.getMessage());
314                            cerr << "Exception: " << message << ".\n";
315                            XMLString::release(&message);
316                            return -1;
317                        }
318                        catch (const SAXParseException& toCatch) {
319                            char* message = XMLString::transcode(toCatch.getMessage());
320                            cerr << "Exception: " << message << ".\n";
321                            XMLString::release(&message);
322                            return -1;
323                        }
324                        catch (...) {
325                                cerr << "Exception: Unhandled exception.\n";
326                            return -1;
327                        }
328
329                        #if defined(SYSTEM_TIME)
330                                duration = ((clock() - start)/clocks_per_sec) * 1000;
331                                fprintf(csv_out,",%5.10f", duration);
332
333                                if(SHOW_ITERATION_RESULTS)
334                                {
335                                        fprintf(stdout, "'%s' interval time ~%5.10f ms.\n",FEATURE_LNAMES[i], duration);
336                                }
337                        #endif
338
339                        #if defined(PAPI)
340                                code_clocker->end_interval(0);
341
342                                if(SHOW_ITERATION_RESULTS)
343                                {
344                                        fprintf(stdout, "'%s' complete.\n",FEATURE_LNAMES[i]);
345                                }
346                        #endif
347
348                }
349
350                /* Write SVG file */
351                #if defined(NAIVE_FORMATTED_IO) || defined(FORMATTED_IO) || defined(MEMCPY_IO) // BUFFERED_IO
352                        fprintf(out_file, "%s", out_buf);
353                        fflush(out_file);
354
355                        if(!out_buf)
356                        {
357                                delete [] out_buf;
358                                out_buf = NULL;
359                        }
360                #endif
361
362                fclose(out_file);
363
364                memset(gml_filename,'\0',strlen(gml_filename));
365                memset(svg_filename,'\0',strlen(svg_filename));
366
367                #if defined(SYSTEM_TIME)
368                        memset(csv_filename,'\0',strlen(csv_filename));
369                #endif
370        }
371
372        fprintf(stdout,"\nProcessing complete.\n");
373
374        #if defined(PAPI)
375                code_clocker->display_system_info();
376                code_clocker->display_raw_event_data();
377                code_clocker->write_xml_file();
378        #endif
379
380        if(layers) {delete layers;}
381        if(gml_src_dir_path) {delete [] gml_src_dir_path;}
382        if(gml_filename) {delete [] gml_filename;}
383        if(svg_dest_dir_path) {delete [] svg_dest_dir_path;}
384        if(svg_filename) {delete [] svg_filename;}
385
386        #if defined(SYSTEM_TIME)
387                fclose(csv_out);
388                if(csv_filename) {delete [] csv_filename;}
389                if(csv_basename) {delete [] csv_basename;}
390        #endif
391
392    delete parser;
393        delete defaultHandler;
394
395        XMLPlatformUtils::Terminate();
396        return 0;
397}
Note: See TracBrowser for help on using the repository browser.