source: trunk/source/visualization/HepRep/src/BHepRepWriter.cc@ 1123

Last change on this file since 1123 was 834, checked in by garnier, 17 years ago

import all except CVS
  • Property svn:executable set to *
File size: 19.8 KB
RevLine 
[834]1// Copyright FreeHEP, 2005.
2
3#include "cheprep/config.h"
4
5#include <iostream>
6#include <algorithm>
7
8#include "cheprep/BHepRepWriter.h"
9
10/**
11 * @author Mark Donszelmann
12 * @version $Id: BHepRepWriter.cc,v 1.9 2005/06/02 21:28:45 duns Exp $
13 */
14namespace cheprep {
15
16 // class variables
17 std::map<std::string, unsigned char> BHepRepWriter::tags;
18 std::map<std::string, unsigned char> BHepRepWriter::attributes;
19 std::map<std::string, unsigned char> BHepRepWriter::values;
20
21 BHepRepWriter::BHepRepWriter( std::ostream& os)
22 : AbstractXMLWriter("heprep"),
23 os(os),
24 singlePrecision(true) {
25
26 // resolve endiannes
27 union { long l; char c[sizeof (long)]; } u;
28 u.l = 1;
29 isBigEndian = (u.c[sizeof (long) - 1] == 1);
30
31// std::cout << "Host is " << (isBigEndian ? "Big-Endian" : "Little-Endian") << "." << std::endl;
32
33 if (tags.size() <= 0) {
34 // tags
35 tags["heprep"] = 0x05;
36 tags["attdef"] = 0x06;
37 tags["attvalue"] = 0x07;
38 tags["instance"] = 0x08;
39 tags["treeid"] = 0x09;
40 tags["action"] = 0x0a;
41 tags["instancetree"] = 0x0b;
42 tags["type"] = 0x0c;
43 tags["typetree"] = 0x0d;
44 tags["layer"] = 0x0e;
45 tags["point"] = 0x0f;
46 }
47
48 if (attributes.size() <= 0) {
49 // attribute names
50 attributes["version"] = 0x05;
51 attributes["xmlns"] = 0x06;
52 attributes["xmlns:xsi"] = 0x07;
53 attributes["xsi:schemaLocation"] = 0x08;
54
55 attributes["valueString"] = 0x10;
56 attributes["valueColor"] = 0x11;
57 attributes["valueLong"] = 0x12;
58 attributes["valueInt"] = 0x13;
59 attributes["valueBoolean"] = 0x14;
60 attributes["valueDouble"] = 0x15;
61
62 attributes["name"] = 0x20;
63 attributes["type"] = 0x22;
64 attributes["showlabel"] = 0x23;
65 attributes["desc"] = 0x24;
66 attributes["category"] = 0x25;
67 attributes["extra"] = 0x26;
68 attributes["x"] = 0x27;
69 attributes["y"] = 0x28;
70 attributes["z"] = 0x29;
71 attributes["qualifier"] = 0x2a;
72 attributes["expression"] = 0x2b;
73 attributes["typetreename"] = 0x2c;
74 attributes["typetreeversion"] = 0x2d;
75 attributes["order"] = 0x2e;
76
77 // for PI
78 attributes["eof"] = 0x7f;
79 }
80
81 if (values.size() <= 0) {
82 // attribute values
83 values["drawas"] = 0x85;
84 values["drawasoptions"] = 0x86;
85 values["visibility"] = 0x87;
86
87 values["label"] = 0x88;
88
89 values["fontname"] = 0x89;
90 values["fontstyle"] = 0x8a;
91 values["fontsize"] = 0x8b;
92 values["fontcolor"] = 0x8c;
93 values["fonthasframe"] = 0x8d;
94 values["fontframecolor"] = 0x8e;
95 values["fontframewidth"] = 0x8f;
96 values["fonthasbanner"] = 0x90;
97 values["fontbannercolor"] = 0x91;
98
99 values["color"] = 0x92;
100 values["framecolor"] = 0x93;
101 values["layer"] = 0x94;
102 values["markname"] = 0x95;
103 values["marksize"] = 0x96;
104 values["marksizemultiplier"] = 0x97;
105 values["marktype"] = 0x98;
106 values["hasframe"] = 0x99;
107 values["framecolor"] = 0x9a;
108 values["framewidth"] = 0x9b;
109
110 values["linestyle"] = 0x9c;
111 values["linewidth"] = 0x9d;
112 values["linewidthmultiplier"] = 0x9e;
113 values["linehasarrow"] = 0x9f;
114
115 values["fillcolor"] = 0xa0;
116 values["filltype"] = 0xa1;
117 values["fill"] = 0xa2;
118
119 values["radius"] = 0xa3;
120 values["phi"] = 0xa4;
121 values["theta"] = 0xa5;
122 values["omega"] = 0xa6;
123 values["radius1"] = 0xa7;
124 values["radius2"] = 0xa8;
125 values["radius3"] = 0xa9;
126 values["curvature"] = 0xaa;
127 values["flylength"] = 0xab;
128 values["faces"] = 0xac;
129
130 values["text"] = 0xad;
131 values["hpos"] = 0xae;
132 values["vpos"] = 0xaf;
133 values["halign"] = 0xb0;
134 values["valign"] = 0xb1;
135
136 values["ispickable"] = 0xb2;
137 values["showparentvalues"] = 0xb3;
138 values["pickparent"] = 0xb4;
139
140 // attvalue values
141 values["false"] = 0xd0;
142 values["true"] = 0xd1;
143
144 values["point"] = 0xd2;
145 values["line"] = 0xd3;
146 values["helix"] = 0xd4;
147 values["polygon"] = 0xd5;
148 values["circle"] = 0xd6;
149 values["curve"] = 0xd7;
150 values["ellipse"] = 0xd8;
151 values["ellipsoid"] = 0xd9;
152 values["prism"] = 0xda;
153 values["cylinder"] = 0xdb;
154 values["ellipseprism"] = 0xdc;
155 values["text"] = 0xdd;
156
157 values["nonzero"] = 0xde;
158 values["evenodd"] = 0xdf;
159
160 values["circle"] = 0xe0;
161 values["box"] = 0xe1;
162 values["uptriangle"] = 0xe2;
163 values["dntriangle"] = 0xe3;
164 values["diamond"] = 0xe4;
165 values["cross"] = 0xe5;
166 values["star"] = 0xe6;
167 values["plus"] = 0xe7;
168 values["hline"] = 0xe8;
169 values["vline"] = 0xe9;
170
171 values["solid"] = 0xea;
172 values["dotted"] = 0xeb;
173 values["dashed"] = 0xec;
174 values["dotdash"] = 0xed;
175
176 values["none"] = 0xee;
177 values["start"] = 0xef;
178 values["end"] = 0xf0;
179 values["both"] = 0xf1;
180
181 values["serif"] = 0xf2;
182 values["sansserif"] = 0xf3;
183 values["monotype"] = 0xf4;
184 values["symbol"] = 0xf5;
185
186 values["plain"] = 0xf6;
187 values["bold"] = 0xf7;
188 values["italic"] = 0xf8;
189
190 values["top"] = 0xf9;
191 values["baseline"] = 0xfa;
192 values["center"] = 0xfb;
193 values["bottom"] = 0xfc;
194
195 values["left"] = 0xfd;
196 values["right"] = 0xfe;
197
198 values["default"] = 0xff;
199 }
200 }
201
202 BHepRepWriter::~BHepRepWriter() {
203 }
204
205 void BHepRepWriter::close() {
206 }
207
208 void BHepRepWriter::openDoc(std::string version, std::string /* encoding */, bool /* standalone */) {
209 stringValues.clear();
210
211 // header
212 writeByte(WBXML_VERSION);
213 writeMultiByteInt(UNKNOWN_PID);
214 writeMultiByteInt(UTF8);
215
216 version = "BinaryHepRep/1.0";
217
218 // string table
219 writeMultiByteInt(version.length()+1);
220
221 // BHepRep Header (as part of the string table)
222 writeString(version);
223
224 }
225
226 void BHepRepWriter::closeDoc(bool /* force */) {
227 writeByte(PI);
228 writeByte(attributes["eof"]);
229 writeByte(END);
230 }
231
232 void BHepRepWriter::openTag(std::string name) {
233 writeTag(name, true);
234 }
235
236 void BHepRepWriter::closeTag() {
237 writePoints();
238 writeByte(END);
239 }
240
241 void BHepRepWriter::printTag(std::string name) {
242 writeTag(name);
243 }
244
245 void BHepRepWriter::writeTag(std::string name, bool hasContent) {
246 std::string s = name;
247 std::transform(s.begin(), s.end(), s.begin(), (int(*)(int)) tolower);
248
249 // find tag
250 if (tags.count(s) <= 0) {
251 std::cerr << "Cannot find tag '" << s << "' in tags table." << std::endl;
252 return;
253 }
254
255 // write tag
256 bool isPoint = (s == "point");
257 bool hasAttributes = (stringAttributes.size() > 0) || (doubleAttributes.size() > (unsigned int)(isPoint ? 3 : 0));
258
259 if (!hasAttributes && isPoint) {
260 // store the point for the future
261 points.push_back(doubleAttributes["x"]);
262 points.push_back(doubleAttributes["y"]);
263 points.push_back(doubleAttributes["z"]);
264 return;
265 }
266
267 writePoints();
268 writeByte(tags[s] | ((hasContent || isPoint) ? CONTENT : 0x00) | (hasAttributes ? ATTRIBUTE : 0x00));
269
270 // write attributes
271 if (hasAttributes) {
272 // write string attributes
273 for (std::map<std::string,std::string>::iterator i = stringAttributes.begin(); i != stringAttributes.end(); i++) {
274 std::string name = i->first;
275 std::string value = i->second;
276
277 // write ATTRSTART
278 writeByte(attributes[name]);
279 std::string v = value;
280 std::transform(v.begin(), v.end(), v.begin(), (int(*)(int)) tolower);
281 if (values.count(v) > 0) {
282 // write ATTRVALUE
283 writeByte(values[v]);
284 } else {
285 if (stringValues.count(value) <= 0) {
286 // define this new string
287 writeStringDefine(value);
288 int index = stringValues.size();
289 stringValues[value] = index;
290 } else {
291 // write string ref
292 writeByte(STR_R);
293 writeMultiByteInt(stringValues[value]);
294 }
295 }
296 }
297 stringAttributes.clear();
298
299 // write color attributes
300 for (std::map<std::string,std::vector<double> >::iterator i = colorAttributes.begin(); i != colorAttributes.end(); i++) {
301 std::string name = i->first;
302 std::vector<double> value = i->second;
303 // write ATTRSTART
304 writeByte(attributes[name]);
305 // write OPAQUE
306 writeByte(OPAQUE);
307 writeMultiByteInt(value.size());
308 writeByte((int)(value[0] * 0xff) & 0xff);
309 writeByte((int)(value[1] * 0xff) & 0xff);
310 writeByte((int)(value[2] * 0xff) & 0xff);
311 if (value.size() > 3) writeByte((int)(value[3] * 0xff) & 0xff);
312 }
313 colorAttributes.clear();
314
315 // write long attributes
316 for (std::map<std::string,int64>::iterator i = longAttributes.begin(); i != longAttributes.end(); i++) {
317 std::string name = i->first;
318 int64 value = i->second;
319 // write ATTRSTART
320 writeByte(attributes[name]);
321 // write OPAQUE
322 writeByte(OPAQUE);
323 writeMultiByteInt(8);
324 writeLong(value);
325 }
326 longAttributes.clear();
327
328 // write int attributes
329 for (std::map<std::string,int>::iterator i = intAttributes.begin(); i != intAttributes.end(); i++) {
330 std::string name = i->first;
331 int value = i->second;
332 // write ATTRSTART
333 writeByte(attributes[name]);
334 // write OPAQUE
335 writeByte(OPAQUE);
336 writeMultiByteInt(4);
337 writeInt(value);
338 }
339 intAttributes.clear();
340
341 // write boolean attributes
342 for (std::map<std::string,bool>::iterator i = booleanAttributes.begin(); i != booleanAttributes.end(); i++) {
343 std::string name = i->first;
344 bool value = i->second;
345 // write ATTRSTART
346 writeByte(attributes[name]);
347 // write ATTRVALUE
348 writeByte(value ? values["true"] : values["false"]);
349 }
350 booleanAttributes.clear();
351
352 // write double attributes
353 for (std::map<std::string,double>::iterator i = doubleAttributes.begin(); i != doubleAttributes.end(); i++) {
354 std::string name = i->first;
355 double value = i->second;
356 if (!isPoint && (name != "x") && (name != "y") && (name != "z")) {
357 // write ATTRSTART
358 writeByte(attributes[name]);
359 // write OPAQUE
360 writeByte(OPAQUE);
361 writeMultiByteInt(singlePrecision ? 4 : 8);
362 writeReal(value);
363 }
364 }
365 doubleAttributes.clear();
366
367 // end of attributes
368 writeByte(END);
369 }
370
371 if (s == "point") {
372 writeByte(OPAQUE);
373 writeMultiByteInt(singlePrecision ? 12 : 24);
374 writeReal(doubleAttributes["x"]);
375 writeReal(doubleAttributes["y"]);
376 writeReal(doubleAttributes["z"]);
377 }
378
379 if (isPoint && !hasContent) {
380 // end this tag
381 writeByte(END);
382 }
383 }
384
385 void BHepRepWriter::writePoints() {
386 if (points.size() <= 0) return;
387
388 writeByte(tags["point"] | CONTENT);
389 writeByte(OPAQUE);
390 writeMultiByteInt(points.size()*(singlePrecision ? 4 : 8));
391 for (std::vector<double>::iterator i = points.begin(); i != points.end(); ) {
392 writeReal(*i++);
393 writeReal(*i++);
394 writeReal(*i++);
395 }
396 writeByte(END);
397
398 points.clear();
399 }
400
401 void BHepRepWriter::setAttribute(std::string name, char* value) {
402 setAttribute(name, (std::string)value);
403 }
404
405 void BHepRepWriter::setAttribute(std::string name, std::string value) {
406 if (name == "value") name = name.append("String");
407
408 // make sure the attribute name is defined
409 if (attributes.count(name) <= 0) {
410 std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
411 return;
412 }
413
414 stringAttributes[name] = value;
415 }
416
417 void BHepRepWriter::setAttribute(std::string name, std::vector<double> value) {
418 if (name == "value") name = name.append("Color");
419
420 // make sure the attribute name is defined
421 if (attributes.count(name) <= 0) {
422 std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
423 return;
424 }
425
426 colorAttributes[name] = value;
427 }
428
429 void BHepRepWriter::setAttribute(std::string name, int64 value) {
430 if (name == "value") name = name.append("Long");
431
432 // make sure the attribute name is defined
433 if (attributes.count(name) <= 0) {
434 std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
435 return;
436 }
437
438 longAttributes[name] = value;
439 }
440
441 void BHepRepWriter::setAttribute(std::string name, int value) {
442 if (name == "value") name = name.append("Int");
443
444 // make sure the attribute name is defined
445 if (attributes.count(name) <= 0) {
446 std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
447 return;
448 }
449
450 intAttributes[name] = value;
451 }
452
453 void BHepRepWriter::setAttribute(std::string name, bool value) {
454 if (name == "value") name = name.append("Boolean");
455
456 // make sure the attribute name is defined
457 if (attributes.count(name) <= 0) {
458 std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
459 return;
460 }
461
462 booleanAttributes[name] = value;
463 }
464
465 void BHepRepWriter::setAttribute(std::string name, double value) {
466 if (name == "value") name = name.append("Double");
467
468 // make sure the attribute name is defined
469 if (attributes.count(name) <= 0) {
470 std::cerr << "Cannot find attribute name '" << name << "' in attributes table, skipped." << std::endl;
471 return;
472 }
473
474 doubleAttributes[name] = value;
475 }
476
477 void BHepRepWriter::writeStringDefine(std::string s) {
478 writeByte(STR_D);
479 writeString(s);
480 }
481
482 void BHepRepWriter::writeMultiByteInt(unsigned int ui) {
483 unsigned char buf[5];
484 int idx = 0;
485
486 do {
487 buf[idx++] = (unsigned char) (ui & 0x7f);
488 ui = ui >> 7;
489 }
490 while (ui != 0);
491
492 while (idx > 1) {
493 writeByte(buf[--idx] | 0x80);
494 }
495 writeByte(buf[0]);
496 }
497
498 void BHepRepWriter::writeReal(double d) {
499 if (singlePrecision) {
500 union {
501 int i;
502 float f;
503 } u;
504 u.f = (float)d;
505 writeInt(u.i);
506 } else {
507 union {
508 int64 i;
509 double d;
510 } u;
511 u.d = d;
512
513 writeLong(u.i);
514 }
515 }
516
517 void BHepRepWriter::writeLong(int64 i) {
518 // write network-order
519 os.put((i >> 56) & 0xff);
520 os.put((i >> 48) & 0xff);
521 os.put((i >> 40) & 0xff);
522 os.put((i >> 32) & 0xff);
523 os.put((i >> 24) & 0xff);
524 os.put((i >> 16) & 0xff);
525 os.put((i >> 8) & 0xff);
526 os.put((i ) & 0xff);
527 }
528
529 void BHepRepWriter::writeInt(int i) {
530 // write network-order
531 os.put((i >> 24) & 0xff);
532 os.put((i >> 16) & 0xff);
533 os.put((i >> 8) & 0xff);
534 os.put((i ) & 0xff);
535 }
536
537 void BHepRepWriter::writeByte(unsigned char b) {
538 os.put((char)b);
539 }
540
541 void BHepRepWriter::writeString(std::string s) {
542 os << s;
543 os.put(0);
544 }
545} // cheprep
Note: See TracBrowser for help on using the repository browser.