==dxf import script ==

script for DXF import by kitsu (Ed Blake) - provide superior import to our native DXF import for many files

1 files changed, 1005 insertions, 0 deletions

diff --git a/release/scripts/import_dxf.py b/release/scripts/import_dxf.py
new file mode 100644
index 00000000000..15bee5b3905
--- /dev/null
+++ b/release/scripts/import_dxf.py
@@ -0,0 +1,1005 @@
+#!BPY
+
+# """
+# Name: 'Drawing eXchange Format (.dxf)'
+# Blender: 243
+# Group: 'Import'
+# Tooltip: 'Import DXF file.'
+# """
+__author__ = 'Kitsu (Ed Blake)'
+__version__ = '0.8 1/2007'
+__url__ = ["elysiun.com", "BlenderArtists.org"]
+__email__ = ["Kitsune_e@yahoo.com"]
+__bpydoc__ = """\
+This is a Blender import script for dxf files.
+
+This script imports the dxf Geometery from dxf versions 2007 and earlier.
+
+Supported:<br>
+   At this time only mesh based imports are supported.<br>
+   Future support for all curve import is planned.<br>
+  <br>
+Currently Supported DXF Ojects:<br>
+     Lines<br>
+     LightWeight polylines<br>
+     True polylines<br>
+     Text<br>
+     Mtext<br>
+     Circles<br>
+     Arcs<br>
+     Ellipses<br>
+     Blocks<br>
+     3Dfaces<br>
+
+Known issues:<br>
+   Does not convert perfectly between Object Coordinate System (OCS) 
+   and World Coordinate System (WCS).  Only rudimentary support for
+   true polylines have been implimented - splines/fitted curves/
+   3d plines/polymeshes are not supported.
+   No support for most 3d entities. Doesn't support the new style object 
+   visability.  There are problems importing some curves/arcs/circles.
+
+Notes:<br>
+   This is primarally a 2d drawing release.  Currently only support for
+   3d faces has been added.
+   Blocks are created on layer 19 then referenced at each insert point.  The
+   insert point is designated with a small 3d crosshair.  This handle does not render.
+
+"""
+
+# --------------------------------------------------------------------------
+# DXF Import v0.8 by Ed Blake (AKA Kitsu)
+# --------------------------------------------------------------------------
+# ***** BEGIN GPL LICENSE BLOCK *****
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+#
+# ***** END GPL LICENCE BLOCK *****
+# --------------------------------------------------------------------------
+
+import Blender
+from Blender import *
+Sys = sys
+try:
+    from dxfReader import readDXF
+except ImportError:
+    import sys
+    curdir = Sys.dirname(Blender.Get('filename'))
+    sys.path.append(curdir)
+from dxfReader import readDXF
+from dxfColorMap import color_map
+from math import *
+
+try:
+    import os
+    if os.name:# != 'mac':
+        import psyco
+        psyco.log()
+        psyco.full(memory=100)
+        psyco.profile(0.05, memory=100)
+        psyco.profile(0.2)
+except ImportError:
+    pass
+
+SCENE = Scene.GetCurrent()
+WORLDX = Mathutils.Vector((1,0,0))
+AUTO = BezTriple.HandleTypes.AUTO
+BYLAYER=256
+
+class Layer:
+    """Dummy layer object."""
+    def __init__(self, name, color, frozen):
+        self.name = name
+        self.color = color
+        self.frozen = frozen
+    
+
+class MatColors:
+    """A smart container for color based materials.
+    
+    This class is a wrapper around a dictionary mapping color indicies to materials.
+    When called with a color index it returns a material corrisponding to that index.
+    Behind the scenes it checks if that index is in its keys, and if not it creates
+    a new material.  It then adds the new index:material pair to its dict and returns
+    the material.
+    """
+    
+    def __init__(self, map):
+        """Expects a dictionary mapping layer names to color idices."""
+        self.map = map
+        self.colors = {}
+    
+    
+    def __call__(self, color=None):
+        """Return the material associated with color.
+        
+        If a layer name is provided the color of that layer is used.
+        """
+        if not color:
+            color = 0
+        if type(color) == str: # Layer name
+            try:
+                color = self.map[color].color # color = layer_map[name].color
+            except KeyError:
+                layer = Layer(name=color, color=0, frozen=False)
+                self.map[color] = layer
+                color = 0
+        color = abs(color)
+        if color not in self.colors.keys():
+            self.add(color)
+        return self.colors[color]
+    
+    
+            
+    
+    def add(self, color):
+        """Create a new material using the provided color index."""
+        global color_map
+        mat = Material.New('ColorIndex-%s' %color)
+        mat.setRGBCol(color_map[color])
+        mat.setMode("Shadeless", "Wire")
+        self.colors[color] = mat
+    
+
+
+
+class Blocks:
+    """A smart container for blocks.
+    
+    This class is a wrapper around a dictionary mapping block names to Blender data blocks.
+    When called with a name string it returns a block corrisponding to that name.
+    Behind the scenes it checks if that name is in its keys, and if not it creates
+    a new data block.  It then adds the new name:block pair to its dict and returns
+    the block.
+    """
+    
+    def __init__(self, map, settings):
+        """Expects a dictionary mapping block names to block objects."""
+        self.map = map
+        self.settings = settings
+        self.blocks = {}
+    
+    
+    def __call__(self, name=None):
+        """Return the data block associated with name.
+        
+        If no name is provided return self.blocks.
+        """
+        if not name:
+            return self.blocks
+        if name not in self.blocks.keys():
+            self.add(name)
+        return self.blocks[name]
+    
+    
+                
+    def add(self, name):
+        """Create a new block group for the block with name."""
+        optimization = self.settings.optimization
+        group = Group.New(name)
+        block = self.map[name]
+        if optimization <= 1:
+            print "\nDrawing %s block entities..." %name
+        drawEntities(block.entities, self.settings, group)
+        if optimization <= 1:
+            print "Done!"
+        self.blocks[name] = group
+    
+    
+
+
+
+class Settings:
+    """A container for all the import settings and objects used by the draw functions.
+    
+    This is like a collection of globally accessable persistant properties and functions.
+    """
+    # Optimization constants
+    MIN = 0
+    MID = 1
+    MAX = 2
+    
+    def __init__(self, drawing, curves):
+        """Given the drawing initialize all the important settings used by the draw functions."""
+        self.curves = curves
+        self.layers = True
+        self.blocks = True
+        self.optimization = self.getOpt()
+        
+        # First sort out all the sections
+        sections = dict([(item.name, item) for item in drawing.data])
+        
+        # The header section may be omited
+        if self.optimization <= self.MID:
+            if 'header' in sections.keys():
+                print "Found header!"
+            else:
+                print "File contains no header!"
+                
+        # The tables section may be partialy or completely missing.
+        if 'tables' in sections.keys():
+            if self.optimization <= self.MID:
+                print "Found tables!"
+            tables = dict([(item.name, item) for item in sections["tables"].data])
+            if 'layer' in tables.keys():
+                if self.optimization <= self.MID:
+                    print "Found layers!"
+                # Read the layers table and get the layer colors
+                self.colors = getLayers(drawing)
+            else:
+                if self.optimization <= self.MID:
+                    print "File contains no layers table!"
+                self.layers = False
+                self.colors = MatColors({})
+        else:
+            if self.optimization <= self.MID:
+                print "File contains no tables!"
+                print "File contains no layers table!"
+            self.layers = False
+            self.colors = MatColors({})
+            
+        # The blocks section may be omited
+        if 'blocks' in sections.keys():
+            if self.optimization <= self.MID:
+                print "Found blocks!"
+            # Read the block definitions and build our block object
+            self.blocks = getBlocks(drawing, self)
+        else:
+            if self.optimization <= self.MID:
+                print "File contains no blocks!"
+            self.blocks = False
+    
+    
+    def getOpt(self):
+        """Ask the user for update optimization level."""
+        Window.WaitCursor(False)
+        
+        retval = Draw.PupIntInput('optimization: ', 1, 0, 2)
+        print "Setting optimization level %s!" %retval
+        
+        Window.WaitCursor(True)
+        return retval
+    
+    
+    def isOff(self, name):
+        """Given a layer name look up the layer object and return its visable status."""
+        # colors are negative if layer is off
+        try:
+            layer = self.colors.map[name]
+        except KeyError:
+            return False
+            
+        if layer.frozen or layer.color < 0:
+            return True
+        else:
+            return False
+        
+    
+    
+
+class Drawer:
+    """Super 'function' for all the entitiy drawing functions.
+    
+        The code for the drawing functions was very repetitive, each differing
+        by only a few lines at most.  So here is a callable class with methods 
+        for each part of the import proccess.
+    """
+    
+    def __init__(self, block=False):
+        self.block = block
+    
+    
+    
+    def __call__(self, entities, settings, group=None):
+        """Call with a list of entities and a settings object to generate Blender geometry."""
+        if entities and settings.optimization <= settings.MID:
+            print "Drawing %ss..." %entities[0].type,
+            
+        if self.block:
+            # create one 'handle' data block to use with all blocks
+            handle = Mesh.New('insert')
+            handle.verts.extend(
+                [(-0.01,0,0),
+                (0.01,0,0),
+                (0,-0.01,0),
+                (0,0.01,0),
+                (0,0,-0.01),
+                (0,0,0.01)]
+            )
+            handle.edges.extend([(0,1),(2,3),(4,5)])
+            
+        # For now we only want model-space objects
+        entities = [entity for entity in entities if entity.space == 0]
+        
+        if group:
+            block_def = True
+        else:
+            block_def = False
+        
+        for entity in entities:
+            if settings.optimization <= settings.MID:
+                print '\b.',
+            # First get the layer group
+            if not block_def:
+                group = self.getGroup('layer %s' %entity.layer) # add overhead just to make things a little cleaner
+            
+            if not self.block:
+                ob = self.draw(entity, settings.curves)
+            else:
+                ob = self.draw(entity, handle, settings)
+            
+            self.setColor(entity, ob, settings)
+            # Link it to the scene and add it to the correct group
+            SCENE.link(ob)
+            self.setGroup(group, ob)
+            
+            # Set the visability
+            if settings.isOff(entity.layer):
+                ob.layers = [20]
+            elif block_def:
+                ob.layers = [19]
+            else:
+                ob.layers = [i+1 for i in range(20)]
+            
+            # # Set the visability
+            # if settings.isOff(entity.layer) or block_def:
+                # ob.restrictDisplay = True
+                # ob.restrictRender = True
+            
+            if settings.optimization == settings.MIN:
+                # I know it's slow to have Blender redraw after each entity type is drawn
+                # But is it really slower than the progress bar?
+                Blender.Redraw()
+        if entities and settings.optimization <= settings.MID:
+            print "\nFinished drawing %ss!" %entities[0].type    
+    def getGroup(self, name):
+        """Returns a Blender group object."""
+        try:
+            group = Group.Get(name)
+        except: # What is the exception?
+            group = Group.New(name)
+        return group    
+    def draw(self, entity):
+        """Dummy method to be over written in subclasses."""
+        pass
+    
+    
+    def setColor(self, entity, ob, settings):
+        # Set the color
+        if entity.color_index == BYLAYER:
+            mat = settings.colors(entity.layer)
+        else:
+            mat = settings.colors(entity.color_index)
+        try:
+            ob.setMaterials([mat])
+        except ValueError:
+            print "material error - %s!" %mat
+        ob.colbits = 0x01 # Set OB materials.    
+    def setGroup(self, group, it):
+        try:
+            group.objects.link(it)
+        except:
+            group.objects.append(it)
+
+    
+def main(filename):
+    editmode = Window.EditMode()    # are we in edit mode?  If so ...
+    if editmode: Window.EditMode(0) # leave edit mode before
+    Window.WaitCursor(True)         # Let the user know we are thinking
+    
+    try:
+        if not filename:
+            print "DXF import: error, no file selected.  Attempting to load default file."
+            try:
+                filename = Sys.expandpath(r".\examples\big-test.dxf")
+            except IOError:
+                print "DXF import: error finding default test file, exiting..."
+                return None
+        if filename:
+            drawing = readDXF(filename)
+            drawDrawing(drawing)
+    finally:
+        # restore state even if things didn't work
+        Window.WaitCursor(False)
+        if editmode: Window.EditMode(1) # and put things back how we fond them
+    
+def getOCS(az):
+    """An implimentation of the Arbitrary Axis Algorithm."""
+    # world x, y, and z axis
+    wx = WORLDX
+    wy = Mathutils.Vector((0,1,0))
+    wz = Mathutils.Vector((0,0,1))
+    
+    #decide if we need to transform our coords
+    if az[0] == 0 and az[1] == 0:
+        return False
+    # elif abs(az[0]) < 0.0001 or abs(az[1]) < 0.0001:
+        # return False
+    az = Mathutils.Vector(az)
+        
+    cap = 0.015625 # square polar cap value (1/64.0)
+    if abs(az.x) < cap and abs(az.y) < cap:
+        ax = Mathutils.CrossVecs(wy, az)
+    else:
+        ax = Mathutils.CrossVecs(wz, az)
+    ax = ax.normalize()
+    ay = Mathutils.CrossVecs(az, ax)
+    ay = ay.normalize()
+    return ax, ay, az
+    
+def transform(normal, obj):
+    """Use the calculated ocs to determine the objects location/orientation in space.
+    
+    Quote from dxf docs:
+        The elevation value stored with an entity and output in DXF files is a sum
+    of the Z-coordinate difference between the UCS XY plane and the OCS XY
+    plane, and the elevation value that the user specified at the time the entity
+    was drawn.
+    """
+    ocs = getOCS(normal)
+    if ocs:
+        #print ocs
+        x, y, z = ocs
+        x = x.resize4D()
+        y = y.resize4D()
+        z = -z.resize4D()
+        x.w = 0
+        y.w = 0
+        z.w = 0
+        o = Mathutils.Vector(obj.loc)
+        o = o.resize4D()
+        mat = Mathutils.Matrix(x, y, z, o)
+        obj.setMatrix(mat)
+    
+def getLayers(drawing):
+    """Build a dictionary of name:color pairs for the given drawing."""
+    tables = drawing.tables
+    for table in tables.data:
+        if table.name == 'layer':
+            layers = table
+            break
+    map = {}
+    for item in layers.data:
+        if type(item) != list and item.type == 'layer':
+            map[item.name] = item
+    colors = MatColors(map)
+    return colors
+def getBlocks(drawing, settings):
+    """Build a dictionary of name:block pairs for the given drawing."""
+    map = {}
+    for item in drawing.blocks.data:
+        if type(item) != list and item.type == 'block':
+            try:
+                map[item.name] = item
+            except KeyError:
+                # annon block
+                print "Cannot map %s - %s!" %(item.name, item)
+    blocks = Blocks(map, settings)
+    return blocks
+def drawDrawing(drawing):
+    """Given a drawing object recreate the drawing in Blender."""
+    print "Getting settings..."
+    # The settings object controls how dxf entities are drawn
+    settings = Settings(drawing, curves=False)
+    
+    if settings.optimization <= settings.MID:
+        print "Drawings entities..."
+    # Draw all the know entity types in the current scene
+    drawEntities(drawing.entities, settings)
+    
+    # Set the visable layers
+    SCENE.setLayers([i+1 for i in range(18)])
+    Blender.Redraw(-1)
+    if settings.optimization <= settings.MID:
+        print "Done!"
+def drawEntities(entities, settings, group=None):
+    """Draw every kind of thing in the entity list.
+    
+    If provided 'group' is the Blender group new entities are to be added to.
+    """
+    for _type, drawer in type_map.items():
+        # for each known type get a list of that type and call the associated draw function
+        drawer(entities.get_type(_type), settings, group)
+    
+
+drawLines = Drawer()
+def drawLine(line, curves=False):
+    """Do all the specific things needed to import lines into Blender."""
+    # Generate the geometery
+    points = line.points
+    edges = [[0, 1]]
+    
+    me = Mesh.New('line')          # create a new mesh
+    
+    me.verts.extend(points)          # add vertices to mesh
+    me.edges.extend(edges)           # add edges to the mesh
+    
+    # Now Create an object
+    ob = Object.New('Mesh', 'line')  # link mesh to an object
+    ob.link(me)
+    
+    return ob
+drawLines.draw = drawLine
+
+
+drawLWpolylines = Drawer()
+def drawLWpolyline(pline, curves=False):
+    """Do all the specific things needed to import plines into Blender."""
+    # Generate the geometery
+    points = []
+    for i in range(len(pline.points)):
+        point = pline.points[i]
+        if not point.bulge:
+            points.append(point.loc)
+        elif point.bulge and i < len(pline.points)-1:# > 0:
+            center, radius, start, end = solveBulge(point, pline.points[i+1])
+            #print center, radius, start, end
+            verts, nosense = drawArc(center, radius, start, end)
+            verts.pop(0) # remove first
+            verts.pop() #remove last
+            if point.bulge >= 0:
+                verts.reverse()
+            points.extend(verts)
+    edges = [[num, num+1] for num in range(len(points)-1)]
+    if pline.closed:
+        edges.append([len(pline.points)-1, 0])
+
+    me = Mesh.New('lwpline')          # create a new mesh
+    
+    me.verts.extend(points)          # add vertices to mesh
+    me.edges.extend(edges)           # add edges to the mesh
+    
+    # Now Create an object
+    ob = Object.New('Mesh', 'lwpline')  # link mesh to an object
+    ob.link(me)
+    transform(pline.extrusion, ob)
+    ob.LocZ = pline.elevation
+    
+    return ob
+drawLWpolylines.draw = drawLWpolyline
+
+drawPolylines = Drawer()
+def drawPolyline(pline, curves=False):
+    """Do all the specific things needed to import plines into Blender."""
+    # Generate the geometery
+    points = []
+    for i in range(len(pline.points)):
+        point = pline.points[i]
+        if not point.bulge:
+            points.append(point.loc)
+        elif point.bulge and i < len(pline.points)-1:# > 0:
+            center, radius, start, end = solveBulge(point, pline.points[i+1])
+            #print center, radius, start, end
+            verts, nosense = drawArc(center, radius, start, end)
+            verts.pop(0) # remove first
+            verts.pop() #remove last
+            if point.bulge >= 0:
+                verts.reverse()
+            points.extend(verts)
+    edges = [[num, num+1] for num in range(len(points)-1)]
+    if pline.closed:
+        edges.append([len(pline.points)-1, 0])
+
+    me = Mesh.New('pline')          # create a new mesh
+    
+    me.verts.extend(points)          # add vertices to mesh
+    me.edges.extend(edges)           # add edges to the mesh
+    
+    # Now Create an object
+    ob = Object.New('Mesh', 'pline')  # link mesh to an object
+    ob.link(me)
+    transform(pline.extrusion, ob)
+    ob.LocZ = pline.elevation
+    
+    return ob
+drawPolylines.draw = drawPolyline
+
+
+def solveBulge(p1, p2):
+    """return the center, radius, start angle, and end angle given two points.
+    
+    Needs to take into account bulge sign.
+    negative = clockwise
+    positive = counter-clockwise
+    
+    to find center given two points, and arc angle
+    calculate radius
+        Cord = sqrt(start^2 + end^2)
+        S = (bulge*Cord)/2
+        radius = ((Cord/2)^2+S^2)/2*S
+    angle of arc = 4*atan( bulge )
+    angle from p1 to center is (180-angle)/2
+    get vector pointing from p1 to p2 (p2 - p1)
+    normalize it and multiply by radius
+    rotate around p1 by angle to center point to center.
+    
+    start angle = angle between (center - p1) and worldX
+    end angle = start angle + angle of arc
+    """
+    bulge = p1.bulge
+    p2 = Mathutils.Vector(p2.loc)
+    p1 = Mathutils.Vector(p1.loc)
+    cord = p2 - p1 # vector from p1 to p2
+    clength = cord.length
+    s = (bulge * clength)/2 # sagitta (height)
+    radius = abs(((clength/2)**2 + s**2)/(2*s)) # magic formula
+    angle = abs(degrees(4*atan(bulge))) # theta (included angle)
+    delta = (180 - angle)/2 # the angle from cord to center
+    if bulge > 0:
+        delta = -delta
+    radial = cord.normalize() * radius # a radius length vector aligned with cord
+    rmat = Mathutils.RotationMatrix(delta, 3, 'Z')
+    center = p1 + (rmat * radial) # rotate radial by delta degrees, then add to p1 to find center
+    if bulge < 0:
+        sv = (p1 - center) # start from point 2
+    else:
+        sv = (p2 - center) # start from point 1
+    start = Mathutils.AngleBetweenVecs(sv, WORLDX) # start angle is the angle between the first leg of the section and the x axis
+    # The next bit is my cludge to figure out if start should be negative
+    rmat = Mathutils.RotationMatrix(start, 3, 'Z')
+    rstart = rmat * sv
+    if Mathutils.AngleBetweenVecs(rstart, WORLDX) < start:
+        start = -start
+    # the end angle is just 'angle' more than start angle
+    end = start + angle
+    return list(center), radius, start, end
+drawTexts = Drawer()
+def drawText(text, curves=False):
+    """Do all the specific things needed to import texts into Blender."""
+    # Generate the geometery
+    txt = Text3d.New("text")
+    txt.setSize(1)
+    txt.setShear(text.oblique/90)
+    txt.setExtrudeDepth(0.5)
+    if text.halignment == 0:
+        align = Text3d.LEFT
+    elif text.halignment == 1:
+        align = Text3d.MIDDLE
+    elif text.halignment == 2:
+        align = Text3d.RIGHT
+    elif text.halignment == 3:
+        align = Text3d.FLUSH
+    else:
+        align = Text3d.MIDDLE
+    txt.setAlignment(align)
+    txt.setText(text.value)
+    
+    # Now Create an object
+    ob = Object.New('Text', 'text')  # link mesh to an object
+    ob.link(txt)
+    
+    transform(text.extrusion, ob)
+    
+    # move the object center to the text location
+    ob.loc = tuple(text.loc)
+    # scale it to the text size
+    ob.SizeX = text.height*text.width_factor
+    ob.SizeY = text.height
+    ob.SizeZ = text.height
+    # and rotate it around z
+    ob.RotZ = radians(text.rotation)
+    
+    return ob
+drawTexts.draw = drawText    
+
+drawMtexts = Drawer()
+def drawMtext(text, curves=False):
+    """Do all the specific things needed to import mtexts into Blender."""
+    # Generate the geometery
+    txt = Text3d.New("mtext")
+    txt.setSize(1)
+    # Blender doesn't give access to its text object width currently
+    # only to the text3d's curve width...
+    #txt.setWidth(text.width/10)
+    txt.setLineSeparation(text.line_space)
+    txt.setExtrudeDepth(0.5)
+    txt.setText(text.value)
+    
+    # Now Create an object
+    ob = Object.New('Text', 'mtext')  # link mesh to an object
+    ob.link(txt)
+    
+    transform(text.extrusion, ob)
+    
+    # move the object center to the text location
+    ob.loc = tuple(text.loc)
+    # scale it to the text size
+    ob.SizeX = text.height*text.width_factor
+    ob.SizeY = text.height
+    ob.SizeZ = text.height
+    # and rotate it around z
+    ob.RotZ = radians(text.rotation)
+    
+    return ob
+drawMtexts.draw = drawMtext
+
+
+
+drawCircles = Drawer()
+def drawCircle(circle, curves=False):
+    """Do all the specific things needed to import circles into Blender."""
+    # Generate the geometery
+    # Now Create an object
+    if curves:
+        ob = drawCurveCircle(circle)
+    else:
+        center = circle.loc
+        radius = circle.radius
+        
+        circ = 2 * pi * radius
+        if circ < 65: # if circumfrance is too small
+            verts = 32 # set a fixed number of 32 verts
+        else:
+            verts = circ/.5 # figure out how many verts we need
+            if verts > 100: # Blender only accepts values
+                verts = 100 # [3:100]
+            
+        c = Mesh.Primitives.Circle(int(verts), radius*2)
+    
+        ob = Object.New('Mesh', 'circle')
+        ob.link(c)                  # link curve data with this object
+        
+    ob.loc = tuple(center)
+    transform(circle.extrusion, ob)
+        
+    return ob
+drawCircles.draw = drawCircle
+
+drawArcs = Drawer()
+def drawArc(arc, curves=False):
+    """Do all the specific things needed to import arcs into Blender."""
+    # Generate the geometery
+    # Now Create an object
+    if curves:
+        ob = drawCurveArc(arc)
+    else:
+        center = arc.loc
+        radius = arc.radius
+        start = arc.start_angle
+        end = arc.end_angle
+        verts, edges = drawArc(None, radius, start, end)
+        
+        a = Mesh.New('arc')
+        
+        a.verts.extend(verts)          # add vertices to mesh
+        a.edges.extend(edges)           # add edges to the mesh
+        
+        ob = Object.New('Mesh', 'arc')
+        ob.link(a)                  # link curve data with this object
+        ob.loc = tuple(center)
+        ob.RotX = radians(180)
+    
+    transform(arc.extrusion, ob)
+    ob.size = (1,1,1)
+    
+    return ob
+drawArcs.draw = drawArc
+
+
+def drawArc(center, radius, start, end, step=0.5):
+    """Draw a mesh arc with the given parameters."""
+    # center is currently set by object
+    
+    # if start > end:
+        # start = start - 360
+    # if end > 360:
+        # end = end%360
+    startmatrix = Mathutils.RotationMatrix(start, 3, "Z")
+    startpoint = startmatrix * Mathutils.Vector((radius, 0, 0))
+    endmatrix = Mathutils.RotationMatrix(end, 3, "Z")
+    endpoint = endmatrix * Mathutils.Vector((radius, 0, 0))
+    points = [startpoint]
+    
+    if end < start:
+        end +=360
+    
+    delta = end - start
+    length = radians(delta) * radius
+    if radius < step*10: # if circumfrance is too small
+        pieces = int(delta/10) # set a fixed step of 10 degrees
+    else:
+        pieces = int(length/step) # figure out how many pieces we need for our arc
+    if pieces == 0: # stupid way to avoid a div by zero error
+        pieces = 1  # what would be a smarter way to fix this?
+    step = delta/pieces # set step so pieces * step = degrees in arc
+    
+    stepmatrix = Mathutils.RotationMatrix(step, 3, "Z")
+    point = Mathutils.Vector(startpoint)
+    for i in range(int(pieces)):
+        point = stepmatrix * point
+        points.append(point)
+    points.append(endpoint)
+    
+    if center:
+        points = [[point[0]+center[0], point[1]+center[1], point[2]+center[2]] for point in points]
+    edges = [[num, num+1] for num in range(len(points)-1)]
+    
+    return points, edges
+drawEllipses = Drawer()
+def drawEllipse(ellipse, curves=False):
+    """Do all the specific things needed to import ellipses into Blender."""
+    # Generate the geometery
+    # Now Create an object
+    if curves:
+        ob = drawCurveArc(ellipse)
+    else:
+        major = Mathutils.Vector(ellipse.major)
+        delta = Mathutils.AngleBetweenVecs(major, WORLDX)
+        center = ellipse.loc
+        radius = major.length
+        start = degrees(ellipse.start_angle)
+        end = degrees(ellipse.end_angle)
+        verts, edges = drawArc(None, radius, start, end)
+        
+        e = Mesh.New('ellipse')
+        
+        e.verts.extend(verts)          # add vertices to mesh
+        e.edges.extend(edges)           # add edges to the mesh
+        
+    
+        ob = Object.New('Mesh', 'arc')
+        ob.link(e)                  # link curve data with this object
+        ob.loc = tuple(center)
+        ob.SizeY = ellipse.ratio
+        #ob.RotZ = radians(delta)
+        ob.RotX = radians(180)
+
+    
+    transform(ellipse.extrusion, ob)
+    ob.RotZ = radians(delta)
+        
+    return ob
+drawEllipses.draw = drawEllipse
+drawBlocks = Drawer(True)
+def drawBlock(insert, handle, settings):
+    """recursivly draw block objects.
+    
+    Blocks are made of three objects:
+        the block_record in the tables section
+        the block in the blocks section
+        the insert object in the entities section
+    
+    block_records give the insert units, blocks provide the objects drawn in the
+    block, and the insert object gives the location/scale/rotation of the block 
+    instances.  To draw a block you must first get a group with all the
+    blocks entities drawn in it, then scale the entities to match the world
+    units, then dupligroup that data to an object matching each insert object."""
+    if settings.blocks:
+        # get our block group
+        block = settings.blocks(insert.block)
+    
+        # Now Create an object
+        ob = Object.New('Mesh', insert.block)
+        ob.link(handle) # Give the object a handle
+        ob.DupGroup = block
+        ob.enableDupGroup = True
+    else:    
+        ob = Object.New('Mesh')
+        
+    ob.loc = tuple(insert.loc)
+    transform(insert.extrusion, ob)
+    ob.RotZ += radians(insert.rotation)
+    ob.size = tuple(insert.scale)
+            
+    return ob
+drawBlocks.draw = drawBlock
+        
+
+drawFaces = Drawer()
+def drawFace(face, curves=False):
+    """Do all the specific things needed to import 3d faces into Blender."""
+    # Generate the geometery
+    points = face.points
+    if len(face.points) > 3:
+        faces = [[0, 1, 2, 3]]
+    else:
+        faces = [[0, 1, 2]]
+    
+    me = Mesh.New('line')          # create a new mesh
+    
+    me.verts.extend(points)          # add vertices to mesh
+    me.faces.extend(faces)           # add faces to the mesh
+    
+    # Now Create an object
+    ob = Object.New('Mesh', '3dface')  # link mesh to an object
+    ob.link(me)
+    
+    return ob
+drawFaces.draw = drawFace
+# Here are some alternate drawing functions for creating curve geometery.
+
+def drawCurveCircle(circle):
+    """Given a dxf circle object return a blender circle object using curves."""
+    c = Curve.New('circle')             # create new  curve data
+    
+    center = circle.loc
+    radius = circle.radius
+    
+    p1 = (0, -radius, 0)
+    p2 = (radius, 0, 0)
+    p3 = (0, radius, 0)
+    p4 = (-radius, 0, 0)
+    
+    p1 = BezTriple.New(p1)
+    p2 = BezTriple.New(p2)
+    p3 = BezTriple.New(p3)
+    p4 = BezTriple.New(p4)
+    
+    curve = c.appendNurb(p1)
+    curve.append(p2)
+    curve.append(p3)
+    curve.append(p4)
+    for point in curve:
+        point.handleTypes = [AUTO, AUTO]
+    curve.flagU = 1 # Set curve cyclic
+    c.update()
+    
+    ob = Object.New('Curve', 'circle')    # make curve object
+    return ob
+    
+def drawCurveArc(arc):
+    """Given a dxf circle object return a blender circle object using curves."""
+    if start > end:
+        start = start - 360
+    startmatrix = Mathutils.RotationMatrix(start, 3, "Z")
+    startpoint = startmatrix * Mathutils.Vector((radius, 0, 0))
+    endmatrix = Mathutils.RotationMatrix(end, 3, "Z")
+    endpoint = endmatrix * Mathutils.Vector((radius, 0, 0))
+    # Note: handles must be tangent to arc and of correct length...
+
+    a = Curve.New('arc')             # create new  curve data
+    
+    center = circle.loc
+    radius = circle.radius
+    
+    p1 = (0, -radius, 0)
+    p2 = (radius, 0, 0)
+    p3 = (0, radius, 0)
+    p4 = (-radius, 0, 0)
+    
+    p1 = BezTriple.New(p1)
+    p2 = BezTriple.New(p2)
+    p3 = BezTriple.New(p3)
+    p4 = BezTriple.New(p4)
+    
+    curve = a.appendNurb(p1)
+    curve.append(p2)
+    curve.append(p3)
+    curve.append(p4)
+    for point in curve:
+        point.handleTypes = [AUTO, AUTO]
+    curve.flagU = 1 # Set curve cyclic
+    a.update()
+    
+    ob = Object.New('Curve', 'arc')    # make curve object
+    return ob
+
+
+type_map = {
+    'line':drawLines,
+    'lwpolyline':drawLWpolylines,
+    'polyline':drawPolylines,
+    'text':drawTexts,
+    'mtext':drawMtexts,
+    'circle':drawCircles,
+    'arc':drawArcs,
+    'ellipse':drawEllipses,
+    'insert':drawBlocks,
+    '3dface':drawFaces
+}
+
+
+if __name__ == "__main__":
+    Window.FileSelector(main, 'Import a DXF file', '*.dxf')