dxf_import.py

"""
 (C) Copyright 2013 Rob Watson rmawatson [at] hotmail.com  and others.

 All rights reserved. This program and the accompanying materials
 are made available under the terms of the GNU Lesser General Public License
 (LGPL) version 2.1 which accompanies this distribution, and is available at
 http://www.gnu.org/licenses/lgpl-2.1.html

 This library 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
 Lesser General Public License for more details.

 Contributors:
     Rob Watson ( rmawatson [at] hotmail )
"""

from PyQt4.QtCore import *
from PyQt4.QtGui import *
import platform,sys,os,re,math
from math import *
from dxfgrabber import *
from dxfgrabber.entities import *
import threading
import Eaglepy


class Line(object):
    def __init__(self,p1,p2):
        self.points = [p1,p2]

    def draw(self,color=(1.0,1.0,1.0,1.0)):

        glBegin(GL_LINES)
        glColor4f(*color)
        glVertex2f(self.points[0].x,self.points[0].y)
        glVertex2f(self.points[1].x,self.points[1].y)
        glEnd()

    def normalized(self):
        return Line(self.points[0],self.points[0] + (self.points[1] - self.points[0]).normalized())

    def toLength(self,value):
        line = self.normalized()
        line.points[0] -= self.points[0]
        line.points[1] -= self.points[0]
        
        line *= value
        
        return Line(self.points[0],line.points[1] + self.points[0])

    def rotate(self,theta):
        return Line(self.points[0],self.points[0] + Point(
                  (self.points[1] - self.points[0]).x * math.cos(theta) - (self.points[1] - self.points[0]).y * math.sin(theta),
                  (self.points[1] - self.points[0]).x * math.sin(theta) + (self.points[1] - self.points[0]).y * math.cos(theta)
                    ))
                    
    
    def asScr(self,wirewidth):
    
        point1Str = str(self.points[0].x) + " " + str(self.points[0].y)
        point2Str = str(self.points[1].x) + " " + str(self.points[1].y)
        
        return "WIRE " + str(wirewidth) + " (" + point1Str + ") (" + point2Str + ");"
    
    def __mul__(self, value):
            return Line(self.points[0]*value,self.points[1]*value)

class Point(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    def draw( self,color=(1.0,1.0,1.0,1.0) ):
        glPointSize(6)
        glBegin(GL_POINTS)
        glColor4f(*color)
        glVertex2f(self.x, self.y)
        glEnd()
        
        
    def __eq__(self,other):
        return (self.x == other.x) & (self.y == other.y)

    def __mul__(self, value):
            return Point(self.x*value,self.y*value)
            
    def __rmul__(self, value):
            return self.__mul__(value)

    def __add__(self,other):
            return Point(self.x+other.x,self.y+other.y)

    def __sub__(self,other):
            return Point(self.x-other.x,self.y-other.y)

    def __div__(self,value):
            return Point(self.x/value,self.y/value)

    def interpolate(self,other,value):
            p = Point(self.x,self.y)
            return p + value*(other-self)
            
    def distance(self,other):
            return abs(math.sqrt(math.pow(other.x - self.x,2) + math.pow(other.y - self.y,2)))


        

    def length(self):
            return abs(sqrt(self.x*self.x + self.y*self.y))


    def normalized(self):
            length = self.length()
            return Point(self.x/length,self.y/length)
            
    def __repr__(self):
        return str(self)
        
    def __str__(self):
        
        return "(" + str(self.x) + ", " + str(self.y) + ")"
            
    def rotate(self,theta,around=None):

            if not around:
                around = Point(0,0)

            return Point(
                      (self - around).x * math.cos(theta) - (self - around).y * math.sin(theta),
                      (self - around).x * math.sin(theta) + (self - around).y * math.cos(theta)
                        )
                    
class BezierCurve(object):


    def solveQuadratic(self,a,b,c):

            result =  math.pow(b,2)- 4*a*c
            if result < 0+sys.float_info.epsilon:
                    return ()
            
            sqroot = math.sqrt(   math.pow(b,2) - 4*a*c)
            return (
                    (-b-sqroot)/(2*a),
                    (-b+sqroot)/(2*a)
                    )

    @classmethod
    def Construct(cls,p1,p2,p3,p4):
        
        
        COLINEAR_VALUE = 0.0001
        #Check for colinear

        if  (p1 == p2 and p3 == p4) or (abs((p1.x*(p2.y-p4.y) + p2.x *(p4.y-p1.y) + p4.x*(p1.y-p2.y))) < COLINEAR_VALUE and \
            abs((p1.x*(p3.y-p4.y) + p3.x *(p4.y-p1.y) + p4.x*(p1.y-p3.y))) < COLINEAR_VALUE):
            return Line(p1,p4)
        elif p1 == p2:
            return QuadraticBezierCurve(p2,p3,p4)
        elif p3 == p4:
            return QuadraticBezierCurve(p1,p2,p3)
        else:
            return CubicBezierCurve(p1,p2,p3,p4)
    
    
    def draw(self,color=(1.0,1.0,1.0,1.0)):
    
            glBegin(GL_LINE_STRIP)
            for i in range(101):
                glColor4f(*color)
                point = self.evaluate(i/100.0)
                glVertex2f(point.x, point.y)
            glEnd()
    
    

        
    

                
class QuadraticBezierCurve(BezierCurve):


        def __init__(self,p1,p2,p3):
                self.points = [p1,p2,p3]


        def evaluate(self,value):
                return (1-value)*((1-value)*self.points[0] +\
                    value*self.points[1]) + \
                    value*((1-value)*self.points[1]+ value*self.points[2])
                    
        def inflection(self):    
            return []
        


        def moveTo(self,point):
        
            moveBy = (self.points[0] - point )
            
            
            transformedPoints = []
            for point in self.points:
                transformedPoints.append(point - moveBy)
            
            return QuadraticBezierCurve(*transformedPoints)
        
    
        def rotate(self,theta,around=None):
    
            if not around:
                around = self.points[0]
                
            rotatedPoints = []
            for point in self.points:
                rotatedPoints.append(point.rotate(theta,around))
            
            
            return QuadraticBezierCurve(*rotatedPoints)
            
            
        def split(self,value):
            
                p1,p2,p3 = self.points
                
                
                r1 = p1
                r2 = p1+value*(p2-p1)
                r3 = self.evaluate(value)

                s1 = r3
                s3 = p3
                s2 = p3 + (1-value)*(p2-p3)
                    
                return (BezierCurve.Construct(r1,r2,r3,r3),BezierCurve.Construct(s1,s2,s3,s3))

        
        def findRoots(self,a,b,c):

            result = self.solveQuadratic((a-2*b+c),(2*b-2*a),a)
            if not result:
                return []
            return [root for root in result if root >= 0 and root <= 1]
        
        def intersect(self,line,onLine=False):

            
            theta  = -((math.pi/2)-atan2(
            (line.points[1] - line.points[0]).x,
            (line.points[1] - line.points[0]).y
            ))

            rotatedLine = Line(Point(0,0),line.points[1].rotate(theta,line.points[0]) )

            rotatedBezier = QuadraticBezierCurve( self.points[0].rotate(theta,line.points[0]),
                                                  self.points[1].rotate(theta,line.points[0]),
                                                  self.points[2].rotate(theta,line.points[0]) )

            
            
            roots = rotatedBezier.findRoots(*[p.y for p in rotatedBezier.points])
    
            if (onLine):
                for root in list(roots):
                    point = rotatedBezier.evaluate(root)
                    
                    if min(rotatedLine.points[0].x-sys.float_info.epsilon,rotatedLine.points[1].x-sys.float_info.epsilon) > point.x or max(rotatedLine.points[0].x+sys.float_info.epsilon,rotatedLine.points[1].x+sys.float_info.epsilon) < point.x:
                        roots.remove(root)
                        
                    elif min(rotatedLine.points[0].y-sys.float_info.epsilon,rotatedLine.points[1].y-sys.float_info.epsilon) > point.y or max(rotatedLine.points[0].y+sys.float_info.epsilon,rotatedLine.points[1].y+sys.float_info.epsilon) < point.y:
                        roots.remove(root)
                
                
            result = []
            for root in roots:
                result.append((root,self.evaluate(root),rotatedBezier.evaluate(root)))
                
            result.sort(key=lambda item:item[2].x)
            result.reverse()
            
            return result
                            
        def draw(self,color=(1.0,1.0,1.0,1.0)):

        
            self.points[0].draw(RED)
            self.points[2].draw(RED)
            
            
            BezierCurve.draw(self,color)
                
class CubicBezierCurve(BezierCurve):


        def __init__(self,p1,p2,p3,p4):
                self.points = [p1,p2,p3,p4]

                self.inflectionpnt = None
        
        def moveTo(self,point):
            
            moveBy = (self.points[0] - point )

            transformedPoints = []
            for point in self.points:
                transformedPoints.append(point - moveBy)
            
            return CubicBezierCurve(*transformedPoints)
        
    
        def rotate(self,theta,around=None):
    
            if not around:
                around = self.points[0]
                
            rotatedPoints = []
            for point in self.points:
                rotatedPoints.append(point.rotate(theta,around))
            
            
            return CubicBezierCurve(*rotatedPoints)
            
        def findRoots(self,a,b,c,d):

                #First derivative roots (starting points for the Cubic Root Solver.

                interestValues = [0.0,1.0]
                quadraticRoots = self.solveQuadratic( (3*d-9*c-3*a+9*b),(6*a-12*b+6*c),(3*b-3*a) )
                result = []
                
                if quadraticRoots:
                    result = [root for root in quadraticRoots if root >= 0 and root <= 1]

                interestValues += result
                interestValues.append((2*b-a-c)/(3*b-3*c-a+d))

                extraValues = []
                for index,value in enumerate(interestValues):
                        slope = math.pow((1-value ),3)*a + 3*math.pow((1-value ),2)*value*b + 3*(1-value )*math.pow(value ,2)*c+math.pow(value ,3)*d
                        if slope == 0:
                                interestValues[index] = value - sys.float_info.epsilon                  
                                extraValues.append( value + sys.float_info.epsilon)
                                
                interestValues += extraValues

                roots = []
                for startValue in interestValues:
                        
                        value = startValue
                        for index in range(10):
                                
                                nm = math.pow((1-value),3)*a + 3*math.pow((1-value),2)*value*b + 3*(1-value)*math.pow(value,2)*c+math.pow(value,3)*d
                                dn = (3*d-9*c-3*a+9*b)*math.pow(value,2) + (6*a-12*b+6*c)*value + (3*b-3*a)

                                if dn == 0: continue

                                nextValue = value - nm/dn


                                if abs(value - nextValue) < sys.float_info.epsilon:
                                        exists = False
                                        for existingValue in roots:
                                                if abs(existingValue - nextValue) < sys.float_info.epsilon:
                                                        exists = True
                                                        break
                                        if not exists:
                                                roots.append(nextValue)
                                                break
                                        
                                value = nextValue

                return roots



        def intersect(self,line,onLine=False):


            theta  = -((math.pi/2)-atan2(
            (line.points[1] - line.points[0]).x,
            (line.points[1] - line.points[0]).y
            ))

            rotatedLine = Line(Point(0,0),line.points[1].rotate(theta,line.points[0]) )
            rotatedBezier = CubicBezierCurve( self.points[0].rotate(theta,line.points[0]),
                                  self.points[1].rotate(theta,line.points[0]),
                                  self.points[2].rotate(theta,line.points[0]),
                                  self.points[3].rotate(theta,line.points[0]))

            roots = rotatedBezier.findRoots(*[p.y for p in rotatedBezier.points])
            self.lastRotBez = rotatedBezier
            self.lastRotLine = rotatedLine
            if (onLine):
                for root in list(roots):
                    point = rotatedBezier.evaluate(root)
                    
                    if min(rotatedLine.points[0].x-sys.float_info.epsilon,rotatedLine.points[1].x-sys.float_info.epsilon) > point.x or max(rotatedLine.points[0].x+sys.float_info.epsilon,rotatedLine.points[1].x+sys.float_info.epsilon) < point.x:
                        roots.remove(root)
                    elif min(rotatedLine.points[0].y-sys.float_info.epsilon,rotatedLine.points[1].y-sys.float_info.epsilon) > point.y or max(rotatedLine.points[0].y+sys.float_info.epsilon,rotatedLine.points[1].y+sys.float_info.epsilon) < point.y:
                        roots.remove(root)
                
                
            result = []
            for root in roots:
                if (root > 0 and root < 1):
                    result.append((root,self.evaluate(root),rotatedBezier.evaluate(root)))
            
            result.sort(key=lambda item:item[2].x)
            result.reverse()
            
            return result
                                    

        def evaluate(self,value):

                return ( math.pow((1.0-value),3) * self.points[0])  + \
                       (3*math.pow((1-value),2)*value * self.points[1]) + \
                       (3*(1-value)*math.pow(value,2) * self.points[2]) + \
                       (math.pow(value,3) * self.points[3])
                        

        def inflection(self):
                P1,C1,C2,P2 = self.points
                
                a = C1 - P1
                b = C2 - C1 - a
                c = P2 - C2 - a -2.0*b

                a1 = b.x*c.y - b.y*c.x
                b1 = a.x*c.y - a.y*c.x
                c1 = a.x*b.y - a.y*b.x

                value =  math.pow(b1,2) - (4*a1*c1)
                self.inflectionpnts = []
                
                if value >0+sys.float_info.epsilon:
                        ta = ( -b1 - math.sqrt(   math.pow(b1,2.0) - 4.0*a1*c1  ) )/(2.0*a1)
                        tb = ( -b1 + math.sqrt(   math.pow(b1,2.0) - 4.0*a1*c1  ) )/(2.0*a1)

                        if ta < 1.0 and ta > 0.0:
                                self.inflectionpnts.append(ta)
                        elif tb < 1.0 and tb > 0.0:
                                self.inflectionpnts.append(tb)

                for index,inflpnt in enumerate(list(self.inflectionpnts)):
                    if inflpnt > (1-0.0000000000001):
                        self.inflectionpnts.remove(inflpnt)
                    elif inflpnt <  0.0000000000001:
                        self.inflectionpnts.remove(inflpnt)
 
                return self.inflectionpnts



        def draw(self,color=(1.0,1.0,1.0,1.0)):

        
            self.points[0].draw(RED)
            self.points[3].draw(RED)
            
            Line(self.points[0],self.points[1]).draw(GREEN)
            Line(self.points[2],self.points[3]).draw(GREEN)
            
            if self.inflectionpnt:
                self.evaluate(self.inflectionpnt).draw()
            BezierCurve.draw(self,color)



        def split(self,value):
            p1,p2,p3,p4 = self.points
            
            
            r1 = p1
            r2 = p1+value*(p2-p1)
            r3 = r2 + value*( (p2 + value*(p3-p2) ) -r2)
            r4 = self.evaluate(value)
            
            
            s1 = r4
            s4 = p4
            s3 = p3 + value*(p4-p3)
            s2 =  (s3+((1-value)*((p2 + value*(p3-p2))-s3)))

            return (CubicBezierCurve(r1,r2,r3,r4),CubicBezierCurve(s1,s2,s3,s4))

class Arc(object):


    def asScr(self,wireWidth):
        
        angleStr  = str(-(self.angle * 180/math.pi))
        angleStr = ("+" + angleStr) if not angleStr.startswith("-") else angleStr
        point1Str = str(self.points[0].x) + " " + str(self.points[0].y)
        point2Str = str(self.points[1].x) + " " + str(self.points[1].y)
        
        
        return "WIRE " + str(wireWidth) + " (" + point1Str + ") " + angleStr + " (" + point2Str + ");"
    

    def values(self):
        return (self.points[0],self.points[1],self.angle)


    def moveTo(self,point):
        
        moveBy = (self.points[0] - point )
        transformedPoints = []
        for point in self.points:
            transformedPoints.append(point - moveBy)
        
        return Arc(*transformedPoints,angle=self.angle)

        


    def rotate(self,theta,around=None):

        if not around:
            around = self.points[0]
            
        rotatedPoints = []
        for point in self.points:
            rotatedPoints.append(point.rotate(theta,around))
        
        
        return Arc(*rotatedPoints,angle=self.angle)
        
    def dot(self,p1,p2):
            return (p1.x*p2.x) + (p1.y*p2.y)

    def __init__(self,p1=None,p2=None,angle=None,tangent=None):

        if not p1 or not p2:
            return
        
        
    
        self.points  = [p1,p2]
        self.angle   = angle
        self.tangent = tangent
        self.chord   = p2- p1
        
        self.recalculate()
        
    def recalculate(self):

        p1,p2 = self.points
        tangentangle = None

        if not self.tangent:
                self.tangent = Point(
                        self.chord.x*cos(self.angle/2) - self.chord.y*sin(self.angle/2),
                        self.chord.x*sin(self.angle/2) + self.chord.y*cos(self.angle/2)
                        )
            
        self.tangent = self.tangent.normalized()


        dotprod = self.dot(self.tangent,self.chord)
        dotprod = min(max(dotprod,-0.9999999),0.9999999)

        tangentangle = acos(dotprod)
        if tangentangle > math.pi/2:
                self.chord = p1 -p2



        self.center  = None
        self.radius  = None


        dot = lambda p1,p2: (p1.x*p2.x) + (p1.y*p2.y)


        if (self.angle):                        
                self.halfangle  = self.angle/2
        elif(self.tangent):
                self.halfangle = math.acos(dot(self.tangent,self.chord) / (self.tangent.length() * self.chord.length()))
                self.angle = self.halfangle*2
        else:
                raise Exception("Angle or Tangent required")


        halfChord   = self.chord.length()/2
        self.radius = halfChord/math.sin(self.halfangle)



        if tangentangle < math.pi/2:
                self.center  = (Point(self.tangent.y , -self.tangent.x ) * self.radius)
        else:
                self.center  = (Point(-self.tangent.y , self.tangent.x ) * self.radius)


        self.center += self.points[1] if tangentangle > math.pi/2 else self.points[0]

        #self.center.draw(GREEN)
    
        self.offsetLine = self.points[0] - self.center
        
        self.offsetAngle = math.pi/2 - math.atan2(self.offsetLine.x,self.offsetLine.y) 

          
    def draw(self,color=(1.0,1.0,1.0,1.0)):

            degtorad = lambda deg: deg*(math.pi/180)
            radtodeg  = lambda rad: rad*(180/math.pi)
            glPointSize(5.0);
            self.points[0].draw(BLUE)
            self.points[1].draw(BLUE)
           
            glBegin(GL_LINE_STRIP)
            glColor4f(*color)
            
            

            
            for i in range( int(radtodeg(self.angle*10)) ):
                    
                    glVertex2f((cos(self.offsetAngle-degtorad((float(i)/10)) )*self.radius)+self.center.x,(sin( self.offsetAngle-degtorad( (float(i)/10)  ))*self.radius)+self.center.y);

            glEnd()
    
    def incenterIntersect(self,bezier):
    
    
        intersectLine = Line(self.center,self.offsetLine+self.center)
        intersectLine = intersectLine.toLength(self.radius)
        intersectLine = intersectLine.rotate(-self.angle)
        intersection  = bezier.intersect(intersectLine)
        
        return intersection[0]
    
    def deviation(self,bezier):
        
        DEVIATION_INCREMENT = 50.0
        
        intersectLine = Line(self.center,self.offsetLine+self.center)
        intersectLine = intersectLine.toLength(self.radius)
        
        lastRotBez = None
        lastRotLine = None
        
        maxAngle = self.angle
        newLine = intersectLine
        
        maxDeviation = (0,(None,None,None))

        for angle in range(0,-int(maxAngle*DEVIATION_INCREMENT)+1,-1):
            currentAngle = angle/DEVIATION_INCREMENT
            
            
            intersection = bezier.intersect(newLine)

            if intersection:
                
                deviation = newLine.points[1].distance(intersection[0][1])
                #newLine.draw()
                if deviation > maxDeviation[0] and intersection[0][0] > 0+0.001 and intersection[0][0] < 1-0.001:

                    lastRotBez = bezier.lastRotBez if hasattr(bezier,"lastRotBez") else None
                    lastRotLine = bezier.lastRotLine if hasattr(bezier,"lastRotLine") else None

                    maxDeviation = (deviation,(currentAngle,intersection[0][1],intersection[0][0]))
                
                newLine = intersectLine.rotate(currentAngle)
            else:
                continue
        """    
        if lastRotBez: lastRotBez.draw()
            
        if lastRotLine: lastRotLine.draw()

        if (lastRotBez):
            for point in lastRotBez.points:
                point.draw(GREEN)

            print "ROOTS",lastRotBez.findRoots(*[point.y for point in lastRotBez.points])

            lastRotBez.evaluate(0.9287).draw()
        """
        #print "MAX ANGLE",maxDeviation[1][0]
        #print "VALUE",maxDeviation[1][2]
        #maxDeviation[1][1].draw()
        return maxDeviation
                


class Biarc(object):
        def __init__(self,bezier):

        
            self.bezier = bezier
            self.calcBezier = bezier.moveTo(Point(0,0))
            self.offsetAngle =  -atan2(self.calcBezier.points[-1].y,self.calcBezier.points[-1].x)
            
        
            self.calcBezier = self.calcBezier.rotate(self.offsetAngle)
            
            self.orderReversed = False
            if self.calcBezier.points[1].y < 0 :    
                self.orderReversed = True
                self.calcBezier.points = list(reversed(self.calcBezier.points))
                
            
            if self.calcBezier.points[1].y < 0:
                self.offsetAngle  -= math.pi
                self.calcBezier = self.calcBezier.rotate(math.pi)
            

            
            if len(self.bezier.points) == 3:
                self.isCubic = False
            
                self.intersection = self.bezier.points[1]
                
            else:
                self.intersection = None
                self.calcTangentIntersection()
            
            
            
            
            self.calcIncenter()
            self.calculateArcs()
                
        def calcTangentIntersection(self):

                p1,p2,p3,p4 = self.calcBezier.points

                xn = (p1.x*p2.y - p1.y*p2.x)*(p3.x - p4.x) - (p1.x - p2.x)*(p3.x*p4.y - p3.y*p4.x)
                yn = (p1.x*p2.y - p1.y*p2.x)*(p3.y - p4.y) - (p1.y - p2.y)*(p3.x*p4.y - p3.y*p4.x)
                dn  = (p1.x - p2.x)*(p3.y - p4.y) - (p1.y - p2.y)*(p3.x - p4.x)

                if not dn:
                        self.intersection = None
                        return

                self.intersection = Point(xn/dn,yn/dn)

            
        def incenterIntersect(self):
            
            return self.arc1.incenterIntersect(self.calcBezier)
            
        
        
        def deviation(self):
            if not self.arc1 and self.arc2:
                return -1
                
                
            return max(self.arc1.deviation(self.calcBezier), self.arc2.deviation(self.calcBezier),key=lambda item:item[0])
            
        def calcIncenter(self):


            if not self.intersection:
                self.incenter = None
                return


            if len(self.calcBezier.points) == 3:
                p1,p2,p3 = self.calcBezier.points
                
                
                
                triPnt1  = p1.interpolate(p3,0.5)
                triPnt2 = p1.interpolate(p2,0.5)
                triPnt3 = p2.interpolate(p3,0.5)
                
                #triPnt1.draw()
                #triPnt2.draw()
                #triPnt3.draw()
                

                triLen1 = triPnt1.distance(triPnt3)
                triLen2 = triPnt1.distance(triPnt2)
                triLen3 = triPnt2.distance(triPnt3)

                #Line(triPnt1,triPnt2).draw()
                #Line(triPnt2,triPnt3).draw()
                #Line(triPnt3,triPnt1).draw()
                
                
                self.incenter =  Point(
                    (triLen1*p1.x + triLen2*p2.x + triLen3 *p3.x)/ (triLen1+triLen2+triLen3),
                    (triLen1*p1.y + triLen2*p2.y + triLen3 *p3.y)/ (triLen1+triLen2+triLen3)
                    )
                    
                """
                self.incenter =  Point(
                    (triLen1*triPnt1.x + triLen2*triPnt2.x + triLen3 *triPnt3.x)/ (triLen1+triLen2+triLen3),
                    (triLen1*triPnt1.y + triLen2*triPnt2.y + triLen3 *triPnt3.y)/ (triLen1+triLen2+triLen3)
                    )
                """
                
                
                
            elif len(self.calcBezier.points) == 4:
                p1,p2,p3,p4 = self.calcBezier.points

                triPnt1  =p1.interpolate(p4,0.5)
                triPnt2 = p1.interpolate(self.intersection,0.5)
                triPnt3 = self.intersection.interpolate(p4,0.5)

                triLen1 = self.intersection.distance(p4)
                triLen2 = p4.distance(p1)
                triLen3 = p1.distance(self.intersection)
                """
                self.incenter =  Point(
                    (triLen1*triPnt1.x + triLen2*triPnt2.x + triLen3 *triPnt3.x)/ (triLen1+triLen2+triLen3),
                    (triLen1*triPnt1.y + triLen2*triPnt2.y + triLen3 *triPnt3.y)/ (triLen1+triLen2+triLen3)
                    )
                    
                """    
                self.incenter =  Point(
                        (triLen1*p1.x + triLen2*self.intersection.x + triLen3 *p4.x)/ (triLen1+triLen2+triLen3),
                        (triLen1*p1.y + triLen2*self.intersection.y + triLen3 *p4.y)/ (triLen1+triLen2+triLen3)
                        )
                

        def draw(self,color=(1.0,1.0,1.0,1.0)):
                
                if not self.intersection:
                        return
                
                
                
                
                if self.arc1:
                
                    drawArc = Arc(self.calcBezier.points[0],self.incenter,self.arc1.angle)
                    drawArc = drawArc.rotate(-self.offsetAngle,self.calcBezier.points[0])
                    drawArc = drawArc.moveTo((self.bezier.points[-1] if self.orderReversed else self.bezier.points[0]))    
                    drawArc.draw(RED)
                    
                if self.arc2:

                    
                    drawArc = Arc(self.incenter,self.calcBezier.points[-1],self.arc2.angle)
                    drawArc = drawArc.rotate(-self.offsetAngle,self.calcBezier.points[0])
                    drawArc = drawArc.moveTo((self.bezier.points[-1] if self.orderReversed else self.bezier.points[0]) + self.incenter.rotate(-self.offsetAngle))
                    drawArc.draw(RED)

        def calculateArcs(self):
            
            if not self.intersection:
                self.arc1 = self.arc2 = None
                return

        
            if len(self.calcBezier.points) == 3:
            
                p1,p2,p3= self.calcBezier.points
                tangent1 = p2 - p1
                tangent2 = p2 - p3
                
                self.arc1 = Arc(p1,self.incenter,tangent=tangent1)
                self.arc2 = Arc(self.incenter,p3,tangent=tangent2)
                
            if len(self.calcBezier.points) == 4:
                p1,p2,p3,p4 = self.calcBezier.points

                
                tangent1 = self.intersection - p1
                tangent2 = self.intersection - p4
                
                self.arc1 = Arc(p1,self.incenter,tangent=tangent1)
                self.arc2 = Arc(self.incenter,p4,tangent=tangent2)
    
            if (self.arc1.angle) > math.pi:
                self.arc1 = None
                self.arc2 = Arc(self.incenter,p4,tangent=tangent2)
            if (self.arc2.angle) > math.pi:
                self.arc2 = None

        def angle(self):
                return self.arc1.angle + self.arc2.angle
        
        def arcs(self):
            resultArcs = []
            if self.arc1:
                resultArc = Arc(self.calcBezier.points[0],self.incenter,self.arc1.angle)
                resultArc = resultArc.rotate(-self.offsetAngle,self.calcBezier.points[0])
                resultArc = resultArc.moveTo((self.bezier.points[-1] if self.orderReversed else self.bezier.points[0]))    
                resultArcs.append(resultArc)
            if self.arc2:
                resultArc = Arc(self.incenter,self.calcBezier.points[-1],self.arc2.angle)
                resultArc = resultArc.rotate(-self.offsetAngle,self.calcBezier.points[0])
                resultArc = resultArc.moveTo((self.bezier.points[-1] if self.orderReversed else self.bezier.points[0]) + self.incenter.rotate(-self.offsetAngle))
                resultArcs.append(resultArc)
    
            return resultArcs

class DXFImportDialog(QDialog):
    
    LABEL_WIDTH = 75
    RIGHT_SPACING_WIDTH = 0

    LAYER_ENUMERATION_COMPLETE_EVENT = QEvent.User+1
    
    def __init__(self):
        
        QDialog.__init__(self)
        
        self.setWindowIcon(QIcon(QPixmap(":/eagleimages/eaglepy.png")))
        self.setWindowTitle("Eagle DXF Importer")
        self.setGeometry(0,0,600,500)
        self.centerToWidget()

        self.setLayout(QVBoxLayout())

        
        
        self.filePathLayout = QHBoxLayout()
        self.filePathName = QLabel("File Path : ")
        self.filePathName.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.filePathName.setMaximumWidth(self.LABEL_WIDTH)
        self.filePathName.setMinimumWidth(self.LABEL_WIDTH)
        self.filePathSelectButton = QPushButton()
        self.filePathSelectButton.setIcon(QApplication.style().standardIcon(QStyle.SP_DirOpenIcon))
        self.filePathEdit = QLineEdit()
        self.filePathLayout.addWidget(self.filePathName)
        self.filePathLayout.addWidget(self.filePathEdit)
        self.filePathLayout.addWidget(self.filePathSelectButton)
        self.filePathLayout.addSpacerItem(QSpacerItem(self.RIGHT_SPACING_WIDTH,1,QSizePolicy.Fixed,QSizePolicy.Fixed))
        
        
        
        
        self.scaleLayout = QHBoxLayout()
        self.scaleName = QLabel("Scale : ")
        self.scaleName.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.scaleName.setMaximumWidth(self.LABEL_WIDTH)
        self.scaleName.setMinimumWidth(self.LABEL_WIDTH)
        self.scaleSpinBox = QDoubleSpinBox()
        self.scaleSpinBox.setMinimum(0.00001)
        self.scaleSpinBox.setMaximum(10)
        
        self.scaleSpinBox.setDecimals(5)
        self.scaleSpinBox.setSingleStep(0.00001)
        self.scaleSpinBox.setValue(1)
        self.scaleLayout.addWidget(self.scaleName)
        self.scaleLayout.addWidget(self.scaleSpinBox)
        self.scaleLayout.addSpacerItem(QSpacerItem(self.RIGHT_SPACING_WIDTH,1,QSizePolicy.Fixed,QSizePolicy.Fixed))
        
        self.toleranceLayout = QHBoxLayout()
        self.toleranceName = QLabel("Tolerance : ")
        self.toleranceName.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.toleranceName.setMaximumWidth(self.LABEL_WIDTH)
        self.toleranceName.setMinimumWidth(self.LABEL_WIDTH)
        self.toleranceSpinBox = QDoubleSpinBox()
        self.toleranceSpinBox.setMinimum(0.0001)
        self.toleranceSpinBox.setMaximum(0.1)
        self.toleranceSpinBox.setSingleStep(0.0001)
        self.toleranceSpinBox.setDecimals(4)
        self.toleranceSpinBox.setValue(0.001)
        self.toleranceLayout.addWidget(self.toleranceName)
        self.toleranceLayout.addWidget(self.toleranceSpinBox)
        self.toleranceLayout.addSpacerItem(QSpacerItem(self.RIGHT_SPACING_WIDTH,1,QSizePolicy.Fixed,QSizePolicy.Fixed))
        
        self.wireWidthLayout = QHBoxLayout()
        self.wireWidthName = QLabel("Wire Width : ")
        self.wireWidthName.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.wireWidthName.setMaximumWidth(self.LABEL_WIDTH)
        self.wireWidthName.setMinimumWidth(self.LABEL_WIDTH)
        self.wireWidthSpinBox = QDoubleSpinBox()
        self.wireWidthSpinBox.setMinimum(0.0001)
        self.wireWidthSpinBox.setMaximum(0.1)
        self.wireWidthSpinBox.setSingleStep(0.0001)
        self.wireWidthSpinBox.setDecimals(4)
        self.wireWidthSpinBox.setValue(0.1)
        self.wireWidthLayout.addWidget(self.wireWidthName)
        self.wireWidthLayout.addWidget(self.wireWidthSpinBox)
        self.wireWidthLayout.addSpacerItem(QSpacerItem(self.RIGHT_SPACING_WIDTH,1,QSizePolicy.Fixed,QSizePolicy.Fixed))        

        self.layerLayout = QHBoxLayout()
        self.layerName = QLabel("Layer : ")
        self.layerName.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
        self.layerName.setMaximumWidth(self.LABEL_WIDTH)
        self.layerName.setMinimumWidth(self.LABEL_WIDTH)
        self.layerComboBox = QComboBox()
        self.layerComboBox.addItem("emumerating..")
        self.layerComboBox.setEnabled(False)
        self.layerLayout.addWidget(self.layerName)
        self.layerLayout.addWidget(self.layerComboBox)
        
        self.fileInfoName = QLabel("File Name : ")
        self.fileInfoName.setAlignment(Qt.AlignTop | Qt.AlignRight)
        self.fileInfoName.setMaximumWidth(self.LABEL_WIDTH)
        self.fileInfoName.setMinimumWidth(self.LABEL_WIDTH)
        
        self.fileInfoTable = QTableWidget()
        self.fileInfoTable.setColumnCount(3)
        self.fileInfoTable.verticalHeader().hide()
        self.fileInfoTable.setHorizontalHeaderLabels(["Layer","Entity Type","Import","Info"])
        self.fileInfoTable.horizontalHeader().setClickable(False)
        self.fileInfoTable.setColumnWidth(0,200)
        self.fileInfoTable.setColumnWidth(1,200)
        self.fileInfoTable.setColumnWidth(2,50)
        self.fileInfoTable.setColumnWidth(3,200)
        self.fileInfoTable.horizontalHeader().setStretchLastSection(True)
        self.fileInfoTable.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.fileInfoLayout =QHBoxLayout()
        self.fileInfoTableLayout = QVBoxLayout()
        #self.fileInfoTableLayout.setSpacing(0)
        
        self.fileInfoTableButtonLayout = QHBoxLayout()
        
        self.fileInfoTableSelectAllButton = QPushButton("Select All")
        self.fileInfoTableDeselectAllButton = QPushButton("Deselect All")
        """
        buttonWidth = 150
        self.fileInfoTableSelectAllButton.setMinimumWidth(buttonWidth)
        self.fileInfoTableSelectAllButton.setMaximumWidth(buttonWidth)
        self.fileInfoTableDeselectAllButton.setMaximumWidth(buttonWidth)
        self.fileInfoTableDeselectAllButton.setMinimumWidth(buttonWidth)
        """
        
        self.fileInfoTableSelectAllButton.clicked.connect(self.selectAll)
        self.fileInfoTableDeselectAllButton.clicked.connect(self.deselectAll)
        
        self.fileInfoTableButtonLayout.addWidget(self.fileInfoTableSelectAllButton)
        self.fileInfoTableButtonLayout.addWidget(self.fileInfoTableDeselectAllButton)
        #self.fileInfoTableButtonLayout.addSpacerItem(QSpacerItem(1,1,QSizePolicy.Expanding,QSizePolicy.Fixed))
        
        self.fileInfoLayout.addWidget(self.fileInfoName)
        self.fileInfoLayout.addLayout(self.fileInfoTableLayout)
        self.fileInfoLayout.addSpacerItem(QSpacerItem(self.RIGHT_SPACING_WIDTH,1,QSizePolicy.Fixed,QSizePolicy.Fixed))
        
        #self.fileInfoTableLayout.addLayout(self.fileInfoTableButtonLayout)    
        self.fileInfoTableLayout.addWidget(self.fileInfoTable)
        
        #self.fileInfoTable.setStyleSheet("QTableWidget::item{border: 0px;padding-left:10px;}")

        
        self.filePathSelectButton.clicked.connect(self.fileOpenDialog)
        
        
        self.importButtonLayout = QHBoxLayout()
        
        self.cancelButton = QPushButton("Cancel")
        self.importButton = QPushButton("Import..")
        self.importCloseButton = QPushButton("Import && Close..")
        buttonWidth  = 150
        buttonHeight = 35
        
        self.importButton.setMinimumWidth(buttonWidth)
        self.importButton.setMaximumWidth(buttonWidth)
        self.importButton.setMinimumHeight(buttonHeight)
        self.importButton.setMaximumHeight(buttonHeight)
        
        self.importCloseButton.setMinimumWidth(buttonWidth)
        self.importCloseButton.setMaximumWidth(buttonWidth)
        self.importCloseButton.setMinimumHeight(buttonHeight)
        self.importCloseButton.setMaximumHeight(buttonHeight)
        
        self.cancelButton.setMinimumWidth(buttonWidth)
        self.cancelButton.setMaximumWidth(buttonWidth)
        self.cancelButton.setMinimumHeight(buttonHeight)
        self.cancelButton.setMaximumHeight(buttonHeight)
        
        self.importButtonLayout.addSpacerItem(QSpacerItem(1,1,QSizePolicy.Expanding,QSizePolicy.Fixed))
        self.importButtonLayout.addWidget(self.cancelButton)
        self.importButtonLayout.addWidget(self.importButton)
        self.importButtonLayout.addWidget(self.importCloseButton)
        
        self.cancelButton.clicked.connect(self.close)
        self.importButton.clicked.connect(self.importFile)
        self.importCloseButton.clicked.connect(self.importCloseFile)
        
        self.layout().addLayout(self.filePathLayout)
        self.layout().addLayout(self.scaleLayout)
        self.layout().addLayout(self.toleranceLayout)
        self.layout().addLayout(self.wireWidthLayout)
        self.layout().addLayout(self.layerLayout)
        self.layout().addLayout(self.fileInfoLayout)
        self.layout().addLayout(self.importButtonLayout)
        
        self.enumerateLayers()
     
    def event(self,event):
    
        if event.type() == self.LAYER_ENUMERATION_COMPLETE_EVENT:
            self.populateLayerCombo()
            event.setAccepted(True)
            return True
            
        return QDialog.event(self,event)

    def populateLayerCombo(self):
    
        for layerItem in self.layerData:
            name,colorIndex,index = layerItem
            map = QPixmap(12,12)
            map.fill(QColor(*self.palette[colorIndex]))
            self.layerComboBox.addItem(QIcon(map),name,QVariant(index))
        
        self.layerComboBox.removeItem(0)
        self.layerComboBox.setEnabled(True)
    
    def enumerateLayers(self):

        self.layerData = []
        def enumerateThread(layerData): 
            
            self.palette = Eaglepy.paletteall()

            for index,layer in enumerate(Eaglepy.ULContext().layers(True)):
                layerData.append((layer.name.get(True),layer.color.get(True),index))
            QApplication.postEvent(self,QEvent(self.LAYER_ENUMERATION_COMPLETE_EVENT))

        threading.Thread(target=enumerateThread,args=[self.layerData]).start()

    def importCloseFile(self):
        if not self.importFile():
            self.close()
        
    def importFile(self):
        filePath = str(self.filePathEdit.text())
    
        if not os.path.exists(filePath):
            messageBox = QMessageBox(
            QMessageBox.Warning,
            "File Not Found","The file path '%s' does not exist. Please specify an existing file." % filePath,
            QMessageBox.Ok,self)
            
            return messageBox.exec_()

        importItems = {}
        for index in range(self.fileInfoTable.rowCount()):
            if self.fileInfoTable.item(index,2).checkState() == Qt.Checked:
                importItems[str(self.fileInfoTable.item(index,0).text())] = str(self.fileInfoTable.item(index,1).text()    )
            
        if not len(importItems.keys()):
            messageBox = QMessageBox(
            QMessageBox.Warning,
            "Nothing Selected","You must select at least one entity to import.",
            QMessageBox.Ok,self)
            
            return messageBox.exec_()
            
            
        

        dxfFile = readfile(filePath)
        
        
        wire_width    = self.wireWidthSpinBox.value()
        scale         = self.scaleSpinBox.value()
        max_deviation = self.toleranceSpinBox.value()
        layer         = str(self.layerComboBox.currentText())
        curves = []
        lines  = []
        
        for entity in dxfFile.entities:
            if not importItems.has_key(entity.layer):
                continue
            
            if not entity.dxftype in importItems[str(entity.layer)]:
                continue
            
            
            if isinstance(entity,Polyline):
                points = [p for p in entity.points()]
                
                pointIndex = 0
                
                while(pointIndex < len(points)-1):
                    lines.append(Line(Point(points[pointIndex][0]*scale,points[pointIndex][1]*scale),Point(points[pointIndex+1][0]*scale,points[pointIndex+1][1]*scale)))
                    pointIndex += 1
                
                continue
                
            
        
            hasControlPoints  = True
            controlPointIndex = 0
            while hasControlPoints:
                points = []
                for index in range(controlPointIndex,controlPointIndex+4):
                    points.append(Point(*list(entity.controlpoints[index][:2])))

                    
                newCurve = BezierCurve.Construct(*[ p*scale for p in points])
                
                if isinstance(newCurve,Line):
                    lines.append(newCurve)
                else:
                    curves.append(newCurve)
                controlPointIndex +=3
                
                if controlPointIndex == len(entity.controlpoints)-1:            
                    break
                
        del dxfFile

        splittingCurves = False
        curveIndex  = 0
        
        if len(curves):
            while not splittingCurves:
 
                thisCurve = curves[curveIndex]
                inflectionPnts = thisCurve.inflection()
                if len(inflectionPnts):
                    
                    curves.pop(curveIndex)
                    splitCurves = thisCurve.split(inflectionPnts[0])
                    
                    for curve in splitCurves:
                        if isinstance(curve,Line):
                            lines.append(curve)
                        else:
                            curves.insert(curveIndex,curve)
                    continue
                
                biarc = Biarc(thisCurve)
                
                if (biarc.angle()) > math.pi/2:
                    intersect = biarc.incenterIntersect()
                    curves.pop(curveIndex)
                    splitCurves = thisCurve.split(intersect[0])
                                    
                    for curve in splitCurves:
                        if isinstance(curve,Line):
                            lines.append(curve)
                        else:
                            curves.insert(curveIndex,curve)
                    continue

                
                deviation = biarc.deviation()    
                if deviation[0] > max_deviation:
                    curves.pop(curveIndex)
                    splitCurves = thisCurve.split(deviation[1][2])
                    for curve in splitCurves:
                        if isinstance(curve,Line):
                            lines.append(curve)
                        else:
                            curves.insert(curveIndex,curve)
                    continue
                
                    
                if curveIndex == len(curves)-1:
                    break
                    
                curveIndex +=1
            
        resultText = "LAYER " + layer + ";SET CONFIRM YES;"
        for index,curve in enumerate(curves):            
            biarc = Biarc(curve)
            arcs = biarc.arcs()
            for arc in arcs:
                resultText += arc.asScr(wire_width)
            
        for index,line in enumerate(lines):
            resultText += line.asScr(wire_width)
        
        resultText += "SET CONFIRM OFF;"
        

        Eaglepy.executescr(resultText);
        
    def selectAll(self):
        for index in range(self.fileInfoTable.rowCount()):
            self.fileInfoTable.item(index,2).setCheckState(Qt.Checked)
            
    def deselectAll(self):
        for index in range(self.fileInfoTable.rowCount()):
            self.fileInfoTable.item(index,2).setCheckState(Qt.Unchecked)
    
    def findEagleWindow(self):
        pass
    
    
    def fileOpenDialog(self):
    
        fileDialog = QFileDialog(filter="*.dxf")
        fileDialog.setFileMode(QFileDialog.ExistingFile)
        
        result = fileDialog.exec_()
        
        if result:        
            self.filePathEdit.setText(fileDialog.selectedFiles()[0])
            self.readFileInfo()
    

    def clearFileInfo(self):
        for index in range(self.fileInfoTable.rowCount()):
            self.fileInfoTable.removeRow(0)
    
    def readFileInfo(self):
    
        self.clearFileInfo()
        filePath = self.filePathEdit.text()
        if not os.path.exists(filePath):
            return
            
         
        dxfFile = readfile(str(filePath))

        entityLayers = {}
        for entity in dxfFile.entities:
            if not entityLayers.has_key( str(entity.layer) ) == None:
                entityLayers[str(entity.layer)] = []
                
            entityLayers[str(entity.layer)].append(entity)
        
        for layername,entityList in entityLayers.iteritems():
            for index,entity in enumerate(entityList):
        
                layerItem  = QTableWidgetItem(layername)
                layerItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                entityItem = QTableWidgetItem(str(entity.dxftype))
                entityItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                
                selectItem = QTableWidgetItem()
                selectItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
                selectItem.setTextAlignment(Qt.AlignRight)
                selectItem.setCheckState(Qt.Checked)
                
                entityInfoText = ""
                if isinstance(entity,Line):
                    entityInfoText += "Start:" + str(entity.start) + ", Stop:" + str(entity.stop)
                elif isinstance(entity,Point):
                    entityInfoText += "Position:" + str(entity.point)
                elif isinstance(entity,Circle):
                    entityInfoText += "Center:" + str(entity.center) + ", Radius:" + str(entity.radius)
                elif isinstance(entity,Arc):
                    entityInfoText += "Center:" + str(entity.center) + ", Radius:" + str(entity.radius) + ", Start Angle:" + str(entity.startangle) + ", End Angle:" + str(entity.endangle)
                elif isinstance(entity,Spline):
                    entityInfoText += "Degree:" + str(entity.degree) + ", Start Tangent:" + str(entity.starttangent) + ", End Tangent:" + str(entity.endtangent) + ", Num Ctrl Pnts:" + str(len(entity.controlpoints)) + \
                    ", Num Fit Pnts:" + str(len(entity.fitpoints)) + ", Num Knots:" + str(len(entity.knots)) + ", Weights:" + str(len(entity.weights))

                    
                entityInfoItem = QTableWidgetItem(entityInfoText)
                
                
                self.fileInfoTable.insertRow(index)
                
                self.fileInfoTable.setItem(index,0,layerItem)
                self.fileInfoTable.setItem(index,1,entityItem)
                self.fileInfoTable.setItem(index,2,selectItem)
                self.fileInfoTable.setItem(index,3,entityInfoItem)
        del dxfFile
        
    def centerToWidget(self,target=None):

        if not target:
            rect = QApplication.desktop().availableGeometry(target if target != None else self)
        else:
            rect = target.geometry()   
        
        center = rect.center()
        self.move(center.x() - self.width()  * 0.5, center.y() - self.height() * 0.5);
      

Eaglepy.initialize()

application = QApplication([])
dialog = DXFImportDialog()
dialog.show()
application.exec_()
Eaglepy.shutdown()