~freecad-community/freecad-extras/drawing-dimensioning

from circleLib import fitCircle_to_path, findCircularArcCentrePoint, pointsAlongCircularArc, fitCircle, arccos2

from numpy import arctan2, pi, linspace, dot, sin, cos, array, cross

        self.elements = [] # for preserving order of path elements, pen movements are not considered elements since they do not result in a direct visual effect

            if a in 'MmLlAaCcQZzHhVv':

        if b in 'MmLlAaCcQZzHhVv' and dParmsXML[-1] <> ' ':

            if parms[j] in list('MmLlAaCcQZzHhVv,'):

                self.elements.append( self.lines[-1] )

            elif parms[j] == 'A' or parms[j] == 'a':

                #print(_end_x, _end_y)

                if parms[j] == 'a':

                    _end_x = _pen_x + _end_x

                    _end_y = _pen_y + _end_y

                    #print(_end_x, _end_y)

                if not ( _pen_x == _end_x and _pen_y == _end_y ) and rX <> 0 and rY <> 0:

                    self.points.append( SvgPathPoint(_end_x, _end_y, end_x, end_y) )

                    self.arcs.append( SvgPathArc( element, _pen_x, _pen_y,  rX, rY, xRotation, largeArc, sweep, _end_x, _end_y ) )

                    self.elements.append(self.arcs[-1])

                self.elements.append(self.bezierCurves[-1])

    '''

    http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands

    #seems to be more accurate then https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/d#Arcto

 

    The elliptical arc command draws a section of an ellipse which meets the following constraints:

 

    -  the arc starts at the current point

    -  the arc ends at point (x, y)

    -  the ellipse has the two radii (rx, ry)

    -  the x-axis of the ellipse is rotated by x-axis-rotation relative to the x-axis of the current coordinate system.

 

    For most situations, there are actually four different arcs (two different ellipses, each with two different arc sweeps) that satisfy these constraints. 

    large-arc-flag and sweep-flag indicate which one of the four arcs are drawn, as follows:

 

    Of the four candidate arc sweeps, two will represent an arc sweep of greater than or equal to 180 degrees (the "large-arc"), and two will represent an arc sweep of less than or equal to 180 degrees (the "small-arc"). 

    If large-arc-flag is '1', then one of the two larger arc sweeps will be chosen; otherwise, if large-arc-flag is '0', one of the smaller arc sweeps will be chosen.

    If sweep-flag is '1', then the arc will be drawn in a "positive-angle" direction (i.e., the ellipse formula x=cx+rx*cos(theta) and y=cy+ry*sin(theta) is evaluated such that theta starts at an angle corresponding to the current point and increases positively until the arc reaches (x,y)). 

    A value of 0 causes the arc to be drawn in a "negative-angle" direction (i.e., theta starts at an angle value corresponding to the current point and decreases until the arc reaches (x,y)).

    '''

 

        """

        3 coordinate systems

          circular coordinates - in this coordinate system, the elipse is circular and unrotated

          elements coordinates - circular coordinates * elipse transformation (x*rX and y*Ry, then rotate to generate the elipse)

          global coordinates - elements coordinates * upper element transformations

        """

        assert not ( _pen_x == _end_x and _pen_y == _end_y )

        assert rX <> 0

        assert rY <> 0

        self._pen_x = _pen_x

        self._pen_y = _pen_y

        self._end_x = _end_x

        self._end_y = _end_y

        self.scaling = element.scaling2() #scaling between element and global coordinates

        self.rX = rX #in elements coordinates

        self.rY = rY #in elements coordinates

        #finding center in circular coordinates 

        # X = T_ellipse dot Y

        # where T_ellipse = [[c -s],[s, c]] dot [[ rX 0],[0 rY]], X is element coordinates, and Y is circular coordinates

        ##import FreeCAD

        ##FreeCAD.Console.PrintMessage( 'Xrotation %f\n' % (self.xRotation))

        c = cos( xRotation*pi/180)

        s = sin( xRotation*pi/180)

        T_ellipse = dot( array([[c,-s] ,[s,c]]), array([[ rX, 0], [0, rY] ]))

        self.T_ellipse = T_ellipse

        #FreeCAD.Console.PrintMessage( 'T %s\n' % (T))

        x1,y1 = numpy.linalg.solve(T_ellipse, [_pen_x, _pen_y])

        x2,y2 = numpy.linalg.solve(T_ellipse, [_end_x, _end_y])

        c_x_Y, c_y_Y = findCircularArcCentrePoint( 1, x1, y1, x2, y2, largeArc==1, sweep==1 )

        self.center_circular = array([c_x_Y, c_y_Y])

        #now determining dtheta in circular coordinates

        #a,b = 1,1

        c = ( ( x2-x1 )**2 + ( y2-y1 )**2 ) ** 0.5

        dtheta = arccos2( ( 1 + 1 - c**2 ) / ( 2 ) ) #cos rule

        #print(x2,x1,y2,y1,c)

        #print(dtheta)

        assert dtheta >= 0

        if largeArc:

            dtheta = 2*pi - dtheta

        if not sweep: # If sweep-flag is '1', then the arc will be drawn in a "positive-angle" direction

            dtheta = -dtheta

        self.dtheta = dtheta

        self.theta_start =  arctan2( y1 - c_y_Y, x1 - c_x_Y)

        self.T_element, self.c_element = element.Transforms()

        #print(self.valueAt(0), element.applyTransforms(_pen_x, _pen_y))

        #print(self.valueAt(1), element.applyTransforms(_end_x, _end_y))

        self.startPoint = self.valueAt(0)

        self.endPoint = self.valueAt(1)

        self.center = self.applyTransforms( self.center_circular )

        self.circular = rX == rY

        if self.circular:

            self.r = rX

 

    def applyTransforms(self, p):

        'position in circular coordinates -> position in elements coordinates -> position in global coordinates'

        return dot( self.T_element, dot(self.T_ellipse, p) ) +  self.c_element

                 

    def valueAt(self, t):

        #position in circular coordinates

        theta = self.theta_start + t*self.dtheta

        p_c = self.center_circular + array([cos(theta), sin(theta)])

        return self.applyTransforms( p_c )

    def valueAt_element(self, t):

        theta = self.theta_start + t*self.dtheta

        p_c = self.center_circular + array([cos(theta), sin(theta)])

        return dot(self.T_ellipse, p_c )

 

    def length(self):

        if self.circular:

            return abs(self.dtheta) * self.rX * self.scaling

        else:

            raise NotImplementedError, "arc.length for ellipsoidal arcs not implemented"

 

    def tangentAt( self, t):

        offset = pi/2 if self.dtheta >= 0 else -pi/2

        theta =  self.theta_start + self.dtheta*t + offset

        p0_ = self.valueAt( t )

        p1_ = p0_ + array([cos(theta), sin(theta)])

        p0 = self.applyTransforms( p0_ )

        p1 = self.applyTransforms( p1_ )

        dP = p1 - p0

        dP = dP / norm(dP)

        return dP

    def t_of_position( self, pos ):

        pos_element = numpy.linalg.solve( self.T_element, pos - self.c_element )

        A = numpy.linalg.solve(self.T_ellipse, pos_element)

        B = self.center_circular

        C = B + array([cos(self.theta_start), sin(self.theta_start)])

        AB = (A - B) / norm(A-B)

        BC = C - B

        theta = arccos2(dot(AB,BC))

        D = array([ A[0] - B[0], A[1] - B[1], 0.0 ])

        E = array([ A[0] - C[0], A[1] - C[1], 0.0 ])

        F = cross(D,E)

        if F[2] < 0:

            theta = -theta

        #print(theta, self.dtheta, theta / self.dtheta )

        return theta / self.dtheta

    def flip( self):

        self.theta_start = self.theta_start + self.dtheta

        self.dtheta = -self.dtheta

        self.sweep = not self.sweep

        self._pen_x, self._pen_y, self._end_x, self._end_y = self._end_x, self._end_y, self._pen_x, self._pen_y

        self.startPoint = self.valueAt(0)

        self.endPoint = self.valueAt(1)

        self.center = self.applyTransforms( self.center_circular )

 

    def svg( self, strokeColor='blue', strokeWidth=0.3, fill= 'none'):

        transform_txt = 'matrix(%f %f %f %f %f %f)' % (

            self.T_element[0,0], self.T_element[0,1], self.T_element[1,0], self.T_element[1,1], self.c_element[0], self.c_element[1]

            )

        return '<path transform="%s" stroke = "%s" stroke-width = "%f" fill = "none" d = "M %f %f A %f %f %f %i %i %f %f"/>' % (

            transform_txt,

            strokeColor,

            strokeWidth / self.scaling,

            self._pen_x, self._pen_y,

            self.rX, self.rY,

            self.xRotation,

            self.largeArc,

            self.sweep,

            self._end_x, self._end_y,

            )

 

    def QPainterPath( self, n=12 ):

        path = QtGui.QPainterPath( QtCore.QPointF( *self.valueAt(0) ) )

        #path.arcTo #dont know what is up with this function so trying something else.

        for t in numpy.linspace(0,1,n)[1:]:

            path.lineTo(*self.valueAt(t))

 

        x_c, y_c = self.applyTransforms(self.center_circular)

        y_c = yT(y_c)

        X = []

        Y = []

        for t in numpy.linspace(0, 1.0, 13):

            x, y = self.valueAt(t)

            Y.append( yT(y) )

        X = []

        Y = []

        for t in numpy.linspace(0, 1.0, n):

            x, y = self.valueAt(t)

    def QPainterPath( self ):

        T = linspace(0, 1, no)