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

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

Updated gml2svg performance Macros and Makefile.

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