source: proto/gml2svg/C/intel/xslt/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: 10.0 KB
Line 
1/*
2        gml2svg.cpp
3    Copyright (C) 2007, 2008 Ken Herdy
4    Version 0.9
5    Licensed to the public under the Open Software License 3.0.
6*/
7
8#if defined(PAPI)
9        #include "cc.h"
10        CC * code_clocker;
11#endif
12
13#include <sys/stat.h>
14#include <stdio.h>
15#include <errno.h>
16#include <linux/errno.h>
17
18#include "vancouver_constants.h"
19#include "gml2svg_util.h"
20#include "xslt_service.hpp"
21#include "xslt_styler.hpp"
22#include "include/util/memoryreader.h"
23#include "include/util/memorywriter.h"
24#include "include/util/filewriter.h"
25
26
27#include "include/xpa/xmldoc/xmldocwriter.h"
28#include "include/xpa/xmldoc/xmldocfactory.h"
29
30#include "include/xpa/dom/domimplementationfactory.h"
31#include "include/xpa/dom/domimplementation.h"
32#include "include/xpa/dom/domwriter.h"
33
34#include <iostream>
35using namespace std;
36
37const int ITERATIONS = 1;
38const bool SHOW_ITERATION_RESULTS = false;
39
40int main (int argc, char* argv[]) {
41
42        char * gml_src_dir_path = NULL;
43        char * xslt_src_dir_path = NULL;
44        char * svg_dest_dir_path = NULL;
45
46        if (argc > 3)
47        {
48                //Test GML src dir ends with FILE_SEPARATOR and exists
49                gml_src_dir_path = new char[strlen(argv[1]) +1 +1];
50                if(gml_src_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
51                strcpy(gml_src_dir_path,argv[1]);
52
53                if(gml_src_dir_path[strlen(gml_src_dir_path)] != FILE_SEPARATOR)
54                {
55                        gml_src_dir_path[strlen(gml_src_dir_path)] = FILE_SEPARATOR;
56                        gml_src_dir_path[strlen(gml_src_dir_path)+1] = '\0';
57                        if(!fopen(gml_src_dir_path,"r"))
58                        {
59                                fprintf(stderr, "GML source directory '%s' does not exist. Terminating the process ...\n", gml_src_dir_path); exit(-1);
60                        }
61                }
62
63                //Test XSLT src dir ends with FILE_SEPARATOR and exists
64                xslt_src_dir_path = new char[strlen(argv[2]) +1 +1];
65                if(xslt_src_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
66                strcpy(xslt_src_dir_path,argv[2]);
67
68                if(xslt_src_dir_path[strlen(xslt_src_dir_path)] != FILE_SEPARATOR)
69                {
70                        xslt_src_dir_path[strlen(xslt_src_dir_path)] = FILE_SEPARATOR;
71                        xslt_src_dir_path[strlen(xslt_src_dir_path)+1] = '\0';
72                        if(!fopen(xslt_src_dir_path,"r"))
73                        {
74                                fprintf(stderr, "XSLT source directory '%s' does not exist. Terminating the process ...\n", xslt_src_dir_path); exit(-1);
75                        }
76                }
77
78                //Test SVG dest dir ends with FILE_SEPARATOR and exists
79                svg_dest_dir_path = new char[strlen(argv[3]) +1 +1];
80                if(svg_dest_dir_path == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
81                strcpy(svg_dest_dir_path,argv[3]);
82
83                if(svg_dest_dir_path[strlen(svg_dest_dir_path)] != FILE_SEPARATOR)
84                {
85                        svg_dest_dir_path[strlen(svg_dest_dir_path)] = FILE_SEPARATOR;
86                        svg_dest_dir_path[strlen(svg_dest_dir_path)+1] = '\0';
87                        if(!fopen(svg_dest_dir_path,"r"))
88                        {
89                                errno = 0;
90                                static mode_t mode = 0755;
91                                if(mkdir(svg_dest_dir_path,mode)<0)
92                                {
93                                        fprintf(stderr,"Cannot create SVG destination directory '%s'. Terminating the proecess ...\n",svg_dest_dir_path);
94                                }
95                        }
96                }
97        }
98        else
99        {
100                fprintf(stderr, "Missing command line arguments.");
101                fprintf(stderr, "Usage: %s <GML directory> <SVG directory> <XSLT directory>\n", argv[0]); exit(-1);
102        }
103
104        //Allocate memory for gml, svg, csv file paths
105        char * gml_filename = new char[strlen(gml_src_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(GML_DOT_EXT) +1];
106        char * svg_filename = new char[strlen(svg_dest_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(SVG_DOT_EXT) +1];
107        char * xslt_filename = new char[strlen(xslt_src_dir_path) + FEATURE_LOCAL_NAMES_MAX_LENGTH_EST + strlen(XSLT_DOT_EXT) +1];
108
109        if(gml_filename == NULL ||  svg_filename == NULL || xslt_filename == NULL) {fprintf(stderr, "Out of memory. Terminating the process ...\n"); exit(-1);}
110
111        #if defined(SYSTEM_TIME)
112                char * csv_filename = new char[strlen(svg_dest_dir_path) + strlen("yyyy-mm-ddThh-mm-ss") + strlen(CSV_DOT_EXT) + 1];
113                char * csv_basename = new char[strlen("yyyy-mm-ddThh-mm-ss") +1];
114                if(csv_filename == NULL || csv_basename == NULL) {fprintf(stderr, "function: main, out of memory. Terminating the process ...\n"); exit(-1);}
115
116                //Create csv file
117                strcpy(csv_filename,svg_dest_dir_path);
118                csv_basename = create_timestamp_filename();
119                strcat(csv_filename,csv_basename);
120                strcat(csv_filename,CSV_DOT_EXT);
121
122                FILE * csv_out;
123                if(!(csv_out = fopen(csv_filename, "w")))
124                {
125                        fprintf(stderr, "Failed to open CSV file '%s' for output. Terminating the process ...\n", csv_filename); exit(-1);
126                }
127        #endif
128
129        #if defined(PAPI)
130
131                #define NUM_EVENTS 1
132                int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
133                int cal_size = 5;
134                code_clocker = new CC(Events,NUM_EVENTS,cal_size);
135
136                string cmd_line;
137                for(int i=0;i<argc;i++)
138                {
139                        cmd_line += argv[i];
140                        cmd_line += " ";
141                }
142                code_clocker->set_cmd(cmd_line);
143
144        #endif
145
146        int layer_count = NUM_FEATURE_COLLECTIONS; // ignore point geometries
147
148        fprintf(stdout, "GML layers ...\n\n");
149        char * layers = layers_2_string(FEATURE_LNAMES, layer_count);
150        fprintf(stdout, "%s\n\n",layers);
151
152        #if defined(SYSTEM_TIME)
153                fprintf(csv_out, "%s, \n",  "Intel (XSLT)");
154                fprintf(csv_out, "\n%s,%s", "GML Directory", gml_src_dir_path);
155                fprintf(csv_out, "\n%s,%s", "XSLT Directory", xslt_src_dir_path);
156        #endif
157
158        #if defined(PAPI)
159                code_clocker->set_param("Parser", "Intel (SAX)");
160                code_clocker->set_param("GML Directory", gml_src_dir_path);
161                code_clocker->set_param("GML Directory", xslt_src_dir_path);
162        #endif
163
164        //Set up Timing
165        #if defined(SYSTEM_TIME)
166                fprintf(csv_out,"\n\n%s,%s", "Layers", "Duration (ms)");
167                clock_t start;
168                double duration = 0;
169                double clocks_per_sec = (double)CLOCKS_PER_SEC;
170        #endif
171
172        //Determine output memory requirement.
173        FILE * stats_file;
174        struct stat fileinfo;
175
176        fprintf(stdout, "\nProcessing layers ...\n\n");
177
178        XsltService xslt_service;
179
180        //Create templates
181        for(int i=0;i<layer_count;i++)
182        {
183                //Set layer specific xslt paths
184                strcpy(xslt_filename,xslt_src_dir_path);
185                strcat(xslt_filename,FEATURE_LNAMES[i]);
186                strcat(xslt_filename,XSLT_DOT_EXT);
187
188                StreamSource xslt_source(xslt_filename);
189                xslt_service.registerTemplates(FEATURE_LNAMES[i], &xslt_source);
190        }
191
192        //Create a memory reader handle
193        char * char_ary = NULL;
194        unsigned long long char_ary_size = 0ull;
195        MemoryReader * gml_memory_reader = MemoryReader::createMemoryReader();
196
197        //XMLDocWriter svg_xml_doc_writer;
198        DOMImplementationFactory* dom_factory = NULL;
199        DOMImplementation* dom_impl = NULL;
200        DOMWriter * svg_dom_writer = NULL;
201
202        dom_factory = DOMImplementationFactory::newInstance();
203        dom_impl = dom_factory->getDOMImplementation();
204        svg_dom_writer = dom_impl->createDOMWriter();
205        FileWriter * svg_file_writer = NULL;
206
207        //Templates handle
208        Templates * templates = NULL;
209        for(int i=0;i<layer_count;i++)
210        {
211                //Set layer specific gml and svg paths
212                strcpy(gml_filename,gml_src_dir_path);
213                strcat(gml_filename,FEATURE_LNAMES[i]);
214                strcat(gml_filename,GML_DOT_EXT);
215
216                //Read the source GML file into memory
217                if(file_to_char_array(gml_filename, &char_ary, &char_ary_size) != 0)
218                {
219                        fprintf(stderr, "Failed to convert '' to char array. Terminating the process ...\n", gml_filename); exit(-1);
220                }
221
222                //Open the in-memory GML source
223                gml_memory_reader->open((XMLChar *)char_ary, char_ary_size);
224
225                //Create output buffer
226                strcpy(svg_filename,svg_dest_dir_path);
227                strcat(svg_filename,FEATURE_LNAMES[i]);
228                strcat(svg_filename,SVG_DOT_EXT);
229
230                svg_file_writer = FileWriter::createFileWriter(svg_filename);
231
232                #if defined(SYSTEM_TIME)
233                        fprintf(csv_out,"\n%s",FEATURE_LNAMES[i]);
234                #endif
235
236                #if defined(PAPI)
237                        code_clocker->set_param("Layer", FEATURE_LNAMES[i]);
238                #endif
239
240                StreamSource gml_stream_source(gml_memory_reader);
241                //StreamResult svg_stream_result(svg_file_writer);
242
243                DOMResult svg_dom_result;
244
245                //Create parameters
246                ParamData screen_height;
247                screen_height.type=STP_STRING;
248                screen_height.data.string=SCREEN_HEIGHT;
249
250                ParamData screen_width;
251                screen_width.type=STP_STRING;
252                screen_width.data.string=SCREEN_WIDTH;
253
254                ParamData bbox;
255                bbox.type=STP_STRING;
256                bbox.data.string=BBOX;
257
258                ParamData x1;
259                x1.type=STP_STRING;
260                x1.data.string=X1;
261
262                ParamData y1;
263                y1.type=STP_STRING;
264                y1.data.string=Y1;
265
266                ParamData x2;
267                x2.type=STP_STRING;
268                x2.data.string=X2;
269
270                ParamData y2;
271                y2.type=STP_STRING;
272                y2.data.string=Y2;
273
274                for(int j=0;j<ITERATIONS;j++)
275                {
276                        #if defined(SYSTEM_TIME)
277                                start = clock();
278                        #endif
279
280                        #if defined(PAPI)
281                                code_clocker->start_interval();
282                        #endif
283
284                        //Create Templates
285                        templates = xslt_service.getTemplates(FEATURE_LNAMES[i]);
286
287                        //Create per iteration transformer
288                        Transformer * transformer = templates->newTransformer();
289
290                        //Set parameters
291                        transformer->setParameter("",XSLT_PARAM_HEIGHT_KEY, screen_width);
292                        transformer->setParameter("",XSLT_PARAM_WIDTH_KEY, screen_width);
293                        transformer->setParameter("",XSLT_PARAM_BBOX_KEY, bbox);
294                        transformer->setParameter("",XSLT_PARAM_X1_KEY, x1);
295                        transformer->setParameter("",XSLT_PARAM_Y1_KEY, y1);
296                        transformer->setParameter("",XSLT_PARAM_X2_KEY, x2);
297                        transformer->setParameter("",XSLT_PARAM_Y2_KEY, y2);
298
299                        //Transform GML layer
300                        //XsltStyler::styleLayer(transformer, &gml_stream_source, &svg_stream_result);
301                        XsltStyler::styleLayer(transformer, &gml_stream_source, &svg_dom_result);
302
303                        //Release the transformer
304                        templates->releaseTransformer(transformer);
305
306                        #if defined(SYSTEM_TIME)
307                                duration = ((clock() - start)/clocks_per_sec) * 1000;
308                                fprintf(csv_out,",%5.10f", duration);
309
310                                if(SHOW_ITERATION_RESULTS)
311                                {
312                                        fprintf(stdout, "'%s' interval time ~%5.10f ms.\n", FEATURE_LNAMES[i], duration);
313                                }
314                        #endif
315
316                        #if defined(PAPI)
317                                code_clocker->end_interval(0);
318
319                                if(SHOW_ITERATION_RESULTS)
320                                {
321                                        fprintf(stdout, "'%s' complete.\n",FEATURE_LNAMES[i]);
322                                }
323                        #endif
324
325                        //Rewind the GML source for each iteration
326                        gml_memory_reader->rewind();
327
328                        templates = NULL;
329                }
330
331                //Free per layer GML source
332                gml_memory_reader->close();
333
334                //Write SVG file
335                svg_dom_writer->serializeDocument(svg_file_writer,(Document *)(svg_dom_result.getNode()));
336
337                //Close the file writer
338                svg_file_writer->close();
339
340        }
341
342        fprintf(stdout,"\nProcessing complete.\n");
343
344        #if defined(PAPI)
345                code_clocker->display_system_info();
346                code_clocker->display_raw_event_data();
347                code_clocker->write_xml_file();
348        #endif
349
350        return 0;
351}
Note: See TracBrowser for help on using the repository browser.