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

Last change on this file since 1956 was 1956, checked in by ksherdy, 7 years ago

Minor updates.

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