mesh_export.py

   1 #!BPY
   2 # $Id$
   3
   4 """
   5 Name: 'MSP GL Mesh (.mesh)...'
   6 Blender: 244
   7 Group: 'Export'
   8 """
   9
  10 import sys
  11 import math
  12 import bpy
  13 import Blender
  14
  15 def make_edge_key(i1, i2):
  16         return (min(i1, i2), max(i1, i2))
  17
  18
  19 class Edge:
  20         def __init__(self, me):
  21                 if me.__class__==Edge:
  22                         self._medge = me._medge
  23                         self.v1 = me.v1
  24                         self.v2 = me.v2
  25                         self.smooth = me.smooth
  26                 else:
  27                         self._medge = me
  28                         self.smooth = False
  29                 self.faces = []
  30
  31         def __getattr__(self, attr):
  32                 return getattr(self._medge, attr)
  33
  34         def check_smooth(self, limit):
  35                 if len(self.faces)!=2:
  36                         return
  37
  38                 d = Blender.Mathutils.DotVecs(self.faces[0].no, self.faces[1].no)
  39                 if (d>limit and self.faces[0].smooth and self.faces[1].smooth) or d>0.999:
  40                         self.smooth = True
  41
  42         def other_face(self, f):
  43                 if f.index==self.faces[0].index:
  44                         if len(self.faces)>=2:
  45                                 return self.faces[1]
  46                         else:
  47                                 return None
  48                 else:
  49                         return self.faces[0]
  50
  51
  52 class Vertex:
  53         def __init__(self, mv):
  54                 if mv.__class__==Vertex:
  55                         self._mvert = mv._mvert
  56                         self.no = mv.no
  57                         self.uv = mv.uv
  58                 else:
  59                         self._mvert = mv
  60                         self.uv = None
  61                 self.flag = False
  62                 self.faces = []
  63                 self.tan = None
  64                 self.bino = None
  65
  66         def __getattr__(self, attr):
  67                 return getattr(self._mvert, attr)
  68
  69         def __cmp__(self, other):
  70                 if other is None:
  71                         return 1
  72                 return cmp(self.index, other.index)
  73
  74         def __str__(self):
  75                 return "<Vert %d (%.4f, %.4f, %.4f) (%.4f, %.4f, %.4f)>"%(self.index, self.co[0], self.co[1], self.co[2], self.no[0], self.no[1], self.no[2])
  76
  77         __repr__ = __str__
  78
  79
  80 class Face:
  81         def __init__(self, mf):
  82                 self._mface = mf
  83                 self.edges = []
  84                 self.verts = [v for v in mf.verts]
  85                 self.flag = False
  86
  87         def __getattr__(self, attr):
  88                 return getattr(self._mface, attr)
  89
  90         def __cmp__(self, other):
  91                 if other is None:
  92                         return 1
  93                 return cmp(self.index, other.index)
  94
  95         def __str__(self):
  96                 return "<Face %d (%s)>"%(self.index, " ".join([str(v.index) for v in self.verts]))
  97
  98         __repr__ = __str__
  99
 100         def pivot_vertices(self, *vt):
 101                 flags = [(v in vt) for v in self.verts]
 102                 l = len(self.verts)
 103                 for i in range(l):
 104                         if flags[i] and not flags[(i+l-1)%l]:
 105                                 return self.verts[i:]+self.verts[:i]
 106
 107         def get_edge(self, v1, v2):
 108                 key = make_edge_key(v1.index, v2.index)
 109                 for e in self.edges:
 110                         if e.key==key:
 111                                 return e
 112                 raise KeyError, "No edge %s"%(key,)
 113
 114
 115 class Line:
 116         def __init__(self, e):
 117                 self.edge = e
 118                 self.verts = [e.v1, e.v2]
 119                 self.flag = False
 120
 121         def __str__(self):
 122                 return "<Line (%d %d)>"%(self.verts[0].index, self.verts[1].index)
 123
 124         __repr__ = __str__
 125
 126
 127 class Mesh:
 128         def __init__(self, m):
 129                 self._mesh = m
 130                 self.verts = [Vertex(v) for v in m.verts]
 131                 self.faces = [Face(f) for f in m.faces]
 132
 133                 for f in self.faces:
 134                         for i in range(len(f.verts)):
 135                                 f.verts[i] = self.verts[f.verts[i].index]
 136                                 f.verts[i].faces.append(f)
 137
 138                 self.edges = dict([(e.key, Edge(e)) for e in m.edges])
 139                 for f in self.faces:
 140                         for k in f.edge_keys:
 141                                 e = self.edges[k]
 142                                 e.faces.append(self.faces[f.index])
 143                                 f.edges.append(e)
 144
 145                 self.lines = [Line(e) for e in self.edges.itervalues() if not e.faces]
 146
 147                 if m.mode&Blender.Mesh.Modes.AUTOSMOOTH:
 148                         smooth_limit = math.cos(m.degr*math.pi/180)
 149                 else:
 150                         smooth_limit = -1
 151
 152                 for e in self.edges.itervalues():
 153                         e.v1 = self.verts[e.v1.index]
 154                         e.v2 = self.verts[e.v2.index]
 155                         e.check_smooth(smooth_limit)
 156
 157         def __getattr__(self, attr):
 158                 return getattr(self._mesh, attr)
 159
 160         def splice(self, other):
 161                 offset = len(self.verts)
 162                 for v in other.verts:
 163                         v.index += offset
 164                         self.verts.append(v)
 165
 166                 offset = len(self.faces)
 167                 for f in other.faces:
 168                         f.index += offset
 169                         self.faces.append(f)
 170
 171                 for e in other.edges.itervalues():
 172                         e.key = make_edge_key(e.v1.index, e.v2.index)
 173                         self.edges[e.key] = e
 174
 175                 self.lines += other.lines
 176
 177         def split_vertices(self, find_group_func, debug):
 178                 groups = []
 179                 for v in self.verts:
 180                         for f in v.faces:
 181                                 f.flag = False
 182
 183                         vg = []
 184                         for f in v.faces:
 185                                 if not f.flag:
 186                                         vg.append(find_group_func(v, f))
 187
 188                         groups.append(vg)
 189
 190                 for i in range(len(self.verts)):
 191                         if len(groups[i])==1:
 192                                 continue
 193
 194                         if debug:
 195                                 print "Vertex %s has %d groups"%(self.verts[i], len(groups[i]))
 196
 197                         for g in groups[i][1:]:
 198                                 v = Vertex(self.verts[i])
 199                                 v.index = len(self.verts)
 200                                 self.verts.append(v)
 201
 202                                 if debug:
 203                                         print "  -> %d %s"%(v.index, [f.index for f in g])
 204
 205                                 for f in g:
 206                                         for j in range(len(f.edges)):
 207                                                 e = f.edges[j]
 208
 209                                                 if e.v1!=self.verts[i] and e.v2!=self.verts[i]:
 210                                                         continue
 211
 212                                                 if debug:
 213                                                         print "  Splitting edge %s with faces %s"%(e.key, e.faces)
 214
 215                                                 if e.other_face(f) not in g and len(e.faces)>=2:
 216                                                         k = e.faces.index(f)
 217                                                         e.faces.remove(f)
 218                                                         e = Edge(e)
 219                                                         f.edges[j] = e
 220                                                         e.faces.append(f)
 221                                                 else:
 222                                                         del self.edges[e.key]
 223
 224                                                 if e.v1==self.verts[i]:
 225                                                         e.v1 = v
 226                                                 elif e.v2==self.verts[i]:
 227                                                         e.v2 = v
 228
 229                                                 e.key = make_edge_key(e.v1.index, e.v2.index)
 230                                                 self.edges[e.key] = e
 231
 232                                         self.verts[i].faces.remove(f)
 233                                         f.verts[f.verts.index(self.verts[i])] = v
 234                                         v.faces.append(f)
 235
 236         def split_smooth(self, debug = False):
 237                 self.split_vertices(self.find_smooth_group, debug)
 238
 239         def split_uv(self, debug = False):
 240                 self.split_vertices(self.find_uv_group, debug)
 241
 242         def find_smooth_group(self, vert, face):
 243                 face.flag = True
 244                 queue = [face]
 245
 246                 for f in queue:
 247                         for e in f.edges:
 248                                 other = e.other_face(f)
 249                                 #if not other or other.index not in face_indices:
 250                                 if other not in vert.faces:
 251                                         continue
 252
 253                                 if e.smooth:
 254                                         if not other.flag:
 255                                                 other.flag = True
 256                                                 queue.append(other)
 257
 258                 return queue
 259
 260         def find_uv_group(self, vert, face):
 261                 uv = face.uv[face.verts.index(vert)]
 262                 face.flag = True
 263                 group = [face]
 264                 for f in vert.faces:
 265                         if not f.flag and f.uv[f.verts.index(vert)]==uv:
 266                                 f.flag = True
 267                                 group.append(f)
 268                 return group
 269
 270         def compute_normals(self):
 271                 for v in self.verts:
 272                         if v.faces:
 273                                 v.no = Blender.Mathutils.Vector()
 274                                 for f in v.faces:
 275                                         v.no += f.no
 276                                 v.no.normalize()
 277                         else:
 278                                 # XXX Should use edges to compute normal
 279                                 v.no = Blender.Mathutils.Vector(0, 0, 1)
 280
 281         def compute_uv(self):
 282                 for v in self.verts:
 283                         if v.faces:
 284                                 v.uv = v.faces[0].uv[v.faces[0].verts.index(v)]
 285
 286         def compute_tbn(self):
 287                 for v in self.verts:
 288                         v.tan = Blender.Mathutils.Vector()
 289                         v.bino = Blender.Mathutils.Vector()
 290                         for f in v.faces:
 291                                 fverts = f.pivot_vertices(False, v)
 292                                 v1 = fverts[1]
 293                                 v2 = fverts[-1]
 294                                 du1 = v1.uv[0]-v.uv[0]
 295                                 du2 = v2.uv[0]-v.uv[0]
 296                                 dv1 = v1.uv[1]-v.uv[1]
 297                                 dv2 = v2.uv[1]-v.uv[1]
 298                                 div = du1*dv2-du2*dv1
 299                                 edge1 = fverts[1].co-fverts[0].co
 300                                 edge2 = fverts[-1].co-fverts[0].co
 301                                 v.tan += (edge1*dv2-edge2*dv1)/div
 302                                 v.bino += (edge2*du1-edge1*du2)/div
 303                         v.tan.normalize()
 304                         v.bino.normalize()
 305
 306         def create_strip(self, face, max_len, debug):
 307                 edge = None
 308                 for e in face.edges:
 309                         other = e.other_face(face)
 310                         if other and not other.flag:
 311                                 edge = e
 312                                 break
 313
 314                 if not edge:
 315                         return None
 316
 317                 if debug:
 318                         print "Starting strip from %s, edge %s"%([v.index for v in face.verts], (edge.v1.index, edge.v2.index))
 319
 320                 verts = face.pivot_vertices(edge.v1, edge.v2)
 321                 if len(verts)==3:
 322                         result = [verts[-1], verts[0]]
 323                 else:
 324                         result = [verts[-2], verts[-1]]
 325
 326                 while 1:
 327                         if debug:
 328                                 print "  Adding %s"%face
 329
 330                         verts = face.pivot_vertices(*result[-2:])
 331                         k = len(result)%2
 332
 333                         face.flag = True
 334                         if len(verts)==4 and not k:
 335                                 result.append(verts[3])
 336                         result.append(verts[2])
 337                         if len(verts)==4 and k:
 338                                 result.append(verts[3])
 339
 340                         if len(result)>=max_len:
 341                                 if debug:
 342                                         print "  Max length exceeded"
 343                                 break
 344
 345                         edge = face.get_edge(*result[-2:])
 346
 347                         if debug:
 348                                 print "  Next edge is %s"%(edge.key, )
 349
 350                         next = edge.other_face(face)
 351                         if not next or next.flag:
 352                                 break
 353                         face = next
 354
 355                 if debug:
 356                         print "  %s"%[v.index for v in result]
 357
 358                 return result
 359
 360
 361 class VertexCache:
 362         def __init__(self, size):
 363                 self.size = size
 364                 self.slots = [-1]*self.size
 365
 366         def fetch(self, v):
 367                 hit = v.index in self.slots
 368                 if hit:
 369                         self.slots.remove(v.index)
 370                 self.slots.append(v.index)
 371                 if not hit:
 372                         del self.slots[0]
 373                 return hit
 374
 375         def fetch_strip(self, strip):
 376                 hits = 0
 377                 for v in strip:
 378                         if self.fetch(v):
 379                                 hits += 1
 380                 return hits
 381
 382         def test_strip(self, strip):
 383                 hits = 0
 384                 for i in range(len(strip)):
 385                         if i>=self.size:
 386                                 break
 387                         if strip[i].index in self.slots[i:]:
 388                                 hits += 1
 389                 return hits
 390
 391
 392 class Exporter:
 393         def __init__(self, fn):
 394                 self.filename = fn
 395                 if fn==None:
 396                         self.out_file = sys.stdout
 397                 else:
 398                         self.out_file = file(fn, "w")
 399                 self.use_strips = True
 400                 self.use_degen_tris = True
 401                 self.max_strip_len = 1024
 402                 self.optimize_cache = False
 403                 self.cache_size = 64
 404                 self.export_lines = True
 405                 self.tbn_vecs = False
 406                 self.compound = False
 407                 self.debug = False
 408                 self.strip_debug = False
 409                 self.split_debug = False
 410
 411         def stripify(self, mesh):
 412                 for f in mesh.faces:
 413                         f.flag = False
 414
 415                 strips = []
 416
 417                 while 1:
 418                         best = 5
 419                         face = None
 420                         for f in mesh.faces:
 421                                 if f.flag:
 422                                         continue
 423                                 score = 0
 424                                 for e in f.edges:
 425                                         other = e.other_face(f)
 426                                         if other and not other.flag:
 427                                                 score += 1
 428                                 if score>0 and score<best:
 429                                         face = f
 430                                         best = score
 431
 432                         if not face:
 433                                 break
 434
 435                         strip = mesh.create_strip(face, self.max_strip_len, self.strip_debug)
 436                         if strip:
 437                                 strips.append(strip)
 438
 439                 loose = [f for f in mesh.faces if not f.flag]
 440
 441                 if self.debug:
 442                         print "%d strips:"%len(strips)
 443                         for i in range(len(strips)):
 444                                 print "  %d: %d indices"%(i, len(strips[i]))
 445                         print "%d loose faces"%len([f for f in mesh.faces if not f.flag])
 446                         nind = sum([len(s) for s in strips])+sum([len(f.verts) for f in loose])
 447                         print "%d indices total"%nind
 448
 449                 if self.use_degen_tris and strips:
 450                         big_strip = []
 451
 452                         cache = None
 453                         total_hits = 0
 454                         if self.optimize_cache:
 455                                 cache = VertexCache(self.cache_size)
 456
 457                         while strips:
 458                                 best = 0
 459                                 if cache:
 460                                         best_hits = 0
 461                                         for i in range(len(strips)):
 462                                                 hits = cache.test_strip(strips[i])
 463                                                 if hits>best_hits:
 464                                                         best = i
 465                                                         best_hits = hits
 466
 467                                 s = strips[best]
 468
 469                                 if big_strip:
 470                                         glue = [big_strip[-1], s[0]]
 471                                         if len(big_strip)%2:
 472                                                 glue += [s[0]]
 473
 474                                         big_strip += glue
 475                                         if cache:
 476                                                 total_hits += cache.fetch_strip(glue)
 477
 478                                 big_strip += s
 479                                 if cache:
 480                                         total_hits += cache.fetch_strip(s)
 481
 482                                 del strips[best]
 483
 484                         for f in loose:
 485                                 if len(big_strip)%2:
 486                                         order = (-1, -2, 0, 1)
 487                                 else:
 488                                         order = (0, 1, -1, -2)
 489                                 verts = [f.verts[i] for i in order[:len(f.verts)]]
 490                                 if big_strip:
 491                                         glue = [big_strip[-1], verts[0]]
 492                                         big_strip += glue
 493                                         if cache:
 494                                                 total_hits += cache.fetch_strip(glue)
 495                                 big_strip += verts
 496                                 if cache:
 497                                         total_hits += cache.fetch_strip(verts)
 498
 499                         strips = [big_strip]
 500                         loose = []
 501
 502                         if self.debug:
 503                                 nind = len(big_strip)
 504                                 print "Big strip has %d indices"%nind
 505                                 if self.optimize_cache:
 506                                         print "%d cache hits"%total_hits
 507
 508                 if self.debug:
 509                         ntris = sum([len(f.verts)-2 for f in mesh.faces])
 510                         print "%.2f indices per triangle"%(float(nind)/max(ntris, 1))
 511
 512                 return strips, loose
 513
 514         def export(self):
 515                 scene = bpy.data.scenes.active
 516
 517                 objs = Blender.Object.GetSelected()
 518                 if not objs:
 519                         raise Exception, "Nothing to export"
 520                 for o in objs:
 521                         if o.getType()!="Mesh":
 522                                 raise Exception, "Can only export Mesh data"
 523
 524                 mesh = Blender.Mesh.New("export_tmp")
 525                 mesh.getFromObject(objs[0])
 526                 mesh = Mesh(mesh)
 527                 if self.compound:
 528                         bmeshes = []
 529                         for o in objs[1:]:
 530                                 bmesh = Blender.Mesh.New("export_tmp")
 531                                 bmesh.getFromObject(o)
 532                                 bmeshes.append(bmesh)
 533                                 mesh.splice(Mesh(bmesh))
 534
 535                 if self.debug:
 536                         ntris = sum([len(f.verts)-2 for f in mesh.faces])
 537                         print "Starting with %d vertices, %d faces (%d triangles) and %d edges"%(len(mesh.verts), len(mesh.faces), ntris, len(mesh.edges))
 538
 539                 mesh.split_smooth(self.split_debug)
 540
 541                 if self.debug:
 542                         print "After smooth splitting %d vertices and %d edges"%(len(mesh.verts), len(mesh.edges))
 543
 544                 mesh.compute_normals()
 545
 546                 if mesh.faceUV:
 547                         mesh.split_uv(self.split_debug)
 548                         if self.debug:
 549                                 print "After UV splitting %d vertices and %d edges"%(len(mesh.verts), len(mesh.edges))
 550
 551                         mesh.compute_uv()
 552                         if self.tbn_vecs:
 553                                 mesh.compute_tbn()
 554
 555                 strips = []
 556                 loose = mesh.faces
 557                 if self.use_strips:
 558                         strips, loose = self.stripify(mesh)
 559
 560                 self.out_file.write("vertices NORMAL3")
 561                 if mesh.faceUV:
 562                         self.out_file.write("_TEXCOORD2")
 563                         if self.tbn_vecs:
 564                                 self.out_file.write("_ATTRIB33_ATTRIB34")
 565                 self.out_file.write("_VERTEX3\n{\n")
 566                 norm = None
 567                 uv = None
 568                 tan = None
 569                 bino = None
 570                 for v in mesh.verts:
 571                         if v.no!=norm:
 572                                 self.out_file.write("\tnormal3 %f %f %f;\n"%tuple(v.no))
 573                                 norm = v.no
 574                         if v.uv!=uv:
 575                                 self.out_file.write("\ttexcoord2 %f %f;\n"%tuple(v.uv))
 576                                 uv = v.uv
 577                         if v.tan!=tan:
 578                                 self.out_file.write("\tattrib3 3 %f %f %f;\n"%tuple(v.tan))
 579                                 tan = v.tan
 580                         if v.bino!=bino:
 581                                 self.out_file.write("\tattrib3 4 %f %f %f;\n"%tuple(v.bino))
 582                                 bino = v.bino
 583                         self.out_file.write("\tvertex3 %f %f %f;\n"%tuple(v.co))
 584                 self.out_file.write("};\n")
 585                 for s in strips:
 586                         self.out_file.write("batch TRIANGLE_STRIP\n{\n\tindices")
 587                         n = 0
 588                         for v in s:
 589                                 self.out_file.write(" %u"%v.index)
 590                                 n += 1;
 591                                 if n%32==0:
 592                                         self.out_file.write(";\n\tindices")
 593                         self.out_file.write(";\n};\n")
 594
 595                 first = True
 596                 for f in loose:
 597                         if first:
 598                                 self.out_file.write("batch TRIANGLES\n{\n")
 599                                 first = False
 600                         for i in range(2, len(f.verts)):
 601                                 self.out_file.write("\tindices %u %u %u;\n"%(f.verts[0].index, f.verts[i-1].index, f.verts[i].index))
 602                 if not first:
 603                         self.out_file.write("};\n")
 604
 605                 if self.export_lines and mesh.lines:
 606                         self.out_file.write("batch LINES\n{\n")
 607                         for l in mesh.lines:
 608                                 self.out_file.write("\tindices %u %u;\n"%(l.verts[0].index, l.verts[1].index))
 609                         self.out_file.write("};\n")
 610
 611
 612 class FrontEnd:
 613         def __init__(self):
 614                 self.config = Blender.Registry.GetKey('mspgl_export', True) or {}
 615                 self.temp_config = Blender.Registry.GetKey('mspgl_export_temp') or {}
 616
 617         def run(self):
 618                 self.use_strips = Blender.Draw.Create(self.config.get('use_strips', True))
 619                 self.use_degen_tris = Blender.Draw.Create(self.config.get('use_degen_tris', True))
 620                 self.max_strip_len = Blender.Draw.Create(self.config.get('max_strip_len', 1024))
 621                 self.optimize_cache = Blender.Draw.Create(self.config.get('optimize_cache', False))
 622                 self.cache_size = Blender.Draw.Create(self.config.get('cache_size', 64))
 623                 self.export_lines = Blender.Draw.Create(self.config.get('export_lines', False))
 624                 self.tbn_vecs = Blender.Draw.Create(self.config.get('tbn_vecs', False))
 625                 self.compound = Blender.Draw.Create(self.config.get('compound', False))
 626                 self.debug = Blender.Draw.Create(self.config.get('debug', False))
 627                 self.strip_debug = Blender.Draw.Create(self.config.get('strip_debug', False))
 628                 self.split_debug = Blender.Draw.Create(self.config.get('split_debug', False))
 629                 ret = Blender.Draw.PupBlock("Export MSP GL mesh",
 630                         [("Use strips", self.use_strips, "Generage OpenGL triangle strips"),
 631                                 ("Use degen tris", self.use_degen_tris, "Use degenerate triangles to combine triangle strips"),
 632                                 ("Max strip len", self.max_strip_len, 4, 16384, "Maximum length of a triangle strip"),
 633                                 ("Optimize cache", self.optimize_cache, "Optimize for vertex cache"),
 634                                 ("Cache size", self.cache_size, 8, 1024, "Cache size to optimize for"),
 635                                 ("Export lines", self.export_lines, "Export lone edges as lines"),
 636                                 ("Compute T/B vecs", self.tbn_vecs, "Compute tangent/binormal vectors for bumpmapping"),
 637                                 ("Compound", self.compound, "Create a compound mesh of all selected objects"),
 638                                 ("Debugging options"),
 639                                 ("Debug", self.debug),
 640                                 ("Debug strips", self.strip_debug),
 641                                 ("Debug splitting", self.split_debug)])
 642                 if ret:
 643                         dirname = self.temp_config.get("dirname", Blender.sys.dirname(Blender.Get("filename")))
 644                         obj = Blender.Object.GetSelected()[0]
 645                         Blender.Window.FileSelector(self.export, "Export MSP GL mesh", "%s/%s.mesh"%(dirname, obj.name))
 646
 647         def draw(self):
 648                 pass
 649
 650         def export(self, fn):
 651                 self.config['use_strips'] = self.use_strips.val
 652                 self.config['use_degen_tris'] = self.use_degen_tris.val
 653                 self.config['max_strip_len'] = self.max_strip_len.val
 654                 self.config['optimize_cache'] = self.optimize_cache.val
 655                 self.config['cache_size'] = self.cache_size.val
 656                 self.config['export_lines'] = self.export_lines.val
 657                 self.config['tbn_vecs'] = self.tbn_vecs.val
 658                 self.config['compound'] = self.compound.val
 659                 self.config['debug'] = self.debug.val
 660                 self.config['strip_debug'] = self.strip_debug.val
 661                 self.config['split_debug'] = self.split_debug.val
 662                 Blender.Registry.SetKey('mspgl_export', self.config, True)
 663
 664                 import os
 665                 self.temp_config["dirname"] = os.path.dirname(fn)
 666                 Blender.Registry.SetKey('mspgl_export_temp', self.temp_config)
 667
 668                 exp = Exporter(fn)
 669                 exp.use_strips = self.use_strips.val
 670                 exp.use_degen_tris = self.use_degen_tris.val
 671                 exp.max_strip_len = self.max_strip_len.val
 672                 exp.optimize_cache = self.optimize_cache.val
 673                 exp.cache_size = self.cache_size.val
 674                 exp.export_lines = self.export_lines.val
 675                 exp.tbn_vecs = self.tbn_vecs.val
 676                 exp.compound = self.compound.val
 677                 exp.debug = self.debug.val
 678                 exp.strip_debug = self.strip_debug.val
 679                 exp.split_debug = self.split_debug.val
 680                 exp.export()
 681
 682
 683 if __name__=="__main__":
 684         fe = FrontEnd()
 685         fe.run()