#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/graphics/charts/piecharts.py

# experimental pie chart script.  Two types of pie - one is a monolithic

#widget with all top-level properties, the other delegates most stuff to

#a wedges collection whic lets you customize the group or every individual

#wedge.

__version__='3.3.0'

__doc__="""Basic Pie Chart class.

This permits you to customize and pop out individual wedges;

supports elliptical and circular pies.

"""

import copy, functools

from math import sin, cos, pi

from reportlab.lib import colors

from reportlab.lib.validators import isColor, isNumber, isListOfNumbersOrNone,\

                                    isListOfNumbers, isColorOrNone, isString,\

                                    isListOfStringsOrNone, OneOf, SequenceOf,\

                                    isBoolean, isListOfColors, isNumberOrNone,\

                                    isNoneOrListOfNoneOrStrings, isTextAnchor,\

                                    isNoneOrListOfNoneOrNumbers, isBoxAnchor,\

                                    isStringOrNone, NoneOr

from reportlab.graphics.widgets.markers import uSymbol2Symbol, isSymbol

from reportlab.lib.attrmap import *

from reportlab.pdfgen.canvas import Canvas

from reportlab.graphics.shapes import Group, Drawing, Ellipse, Wedge, String, STATE_DEFAULTS, ArcPath, Polygon, Rect, PolyLine, Line

from reportlab.graphics.widgetbase import Widget, TypedPropertyCollection, PropHolder

from reportlab.graphics.charts.areas import PlotArea

from reportlab.graphics.charts.legends import _objStr

from reportlab.graphics.charts.textlabels import Label

_ANGLE2BOXANCHOR={0:'w', 45:'sw', 90:'s', 135:'se', 180:'e', 225:'ne', 270:'n', 315: 'nw', -45: 'nw'}

_ANGLE2RBOXANCHOR={0:'e', 45:'ne', 90:'n', 135:'nw', 180:'w', 225:'sw', 270:'s', 315: 'se', -45: 'se'}

_ANGLELO    = 1e-7

_ANGLEHI    = 360.0 - _ANGLELO

class WedgeLabel(Label):

    def _checkDXY(self,ba):

        pass

    def _getBoxAnchor(self):

        ba = self.boxAnchor

        if ba in ('autox','autoy'):

            na = (int((self._pmv%360)/45.)*45)%360

            if not (na % 90): # we have a right angle case

                da = (self._pmv - na) % 360

                if abs(da)>5:

                    na += (da>0 and 45 or -45)

            ba = (getattr(self,'_anti',None) and _ANGLE2RBOXANCHOR or _ANGLE2BOXANCHOR)[na]

            self._checkDXY(ba)

        return ba

class WedgeProperties(PropHolder):

    """This holds descriptive information about the wedges in a pie chart.

    It is not to be confused with the 'wedge itself'; this just holds

    a recipe for how to format one, and does not allow you to hack the

    angles.  It can format a genuine Wedge object for you with its

    format method.

    """

    _attrMap = AttrMap(

        strokeWidth = AttrMapValue(isNumber,desc='Width of the wedge border'),

        fillColor = AttrMapValue(isColorOrNone,desc='Filling color of the wedge'),

        strokeColor = AttrMapValue(isColorOrNone,desc='Color of the wedge border'),

        strokeDashArray = AttrMapValue(isListOfNumbersOrNone,desc='Style of the wedge border, expressed as a list of lengths of alternating dashes and blanks'),

        strokeLineCap = AttrMapValue(OneOf(0,1,2),desc="Line cap 0=butt, 1=round & 2=square"),

        strokeLineJoin = AttrMapValue(OneOf(0,1,2),desc="Line join 0=miter, 1=round & 2=bevel"),

        strokeMiterLimit = AttrMapValue(isNumber,desc='Miter limit control miter line joins'),

        popout = AttrMapValue(isNumber,desc="How far of centre a wedge to pop"),

        fontName = AttrMapValue(isString,desc='Name of the font of the label text'),

        fontSize = AttrMapValue(isNumber,desc='Size of the font of the label text in points'),

        fontColor = AttrMapValue(isColorOrNone,desc='Color of the font of the label text'),

        labelRadius = AttrMapValue(isNumber,desc='Distance between the center of the label box and the center of the pie, expressed in times the radius of the pie'),

        label_dx = AttrMapValue(isNumber,desc='X Offset of the label'),

        label_dy = AttrMapValue(isNumber,desc='Y Offset of the label'),

        label_angle = AttrMapValue(isNumber,desc='Angle of the label, default (0) is horizontal, 90 is vertical, 180 is upside down'),

        label_boxAnchor = AttrMapValue(isBoxAnchor,desc='Anchoring point of the label'),

        label_boxStrokeColor = AttrMapValue(isColorOrNone,desc='Border color for the label box'),

        label_boxStrokeWidth = AttrMapValue(isNumber,desc='Border width for the label box'),

        label_boxFillColor = AttrMapValue(isColorOrNone,desc='Filling color of the label box'),

        label_strokeColor = AttrMapValue(isColorOrNone,desc='Border color for the label text'),

        label_strokeWidth = AttrMapValue(isNumber,desc='Border width for the label text'),

        label_text = AttrMapValue(isStringOrNone,desc='Text of the label'),

        label_leading = AttrMapValue(isNumberOrNone,desc=''),

        label_width = AttrMapValue(isNumberOrNone,desc='Width of the label'),

        label_maxWidth = AttrMapValue(isNumberOrNone,desc='Maximum width the label can grow to'),

        label_height = AttrMapValue(isNumberOrNone,desc='Height of the label'),

        label_textAnchor = AttrMapValue(isTextAnchor,desc='Maximum height the label can grow to'),

        label_visible = AttrMapValue(isBoolean,desc="True if the label is to be drawn"),

        label_topPadding = AttrMapValue(isNumber,'Padding at top of box'),

        label_leftPadding = AttrMapValue(isNumber,'Padding at left of box'),

        label_rightPadding = AttrMapValue(isNumber,'Padding at right of box'),

        label_bottomPadding = AttrMapValue(isNumber,'Padding at bottom of box'),

        label_simple_pointer = AttrMapValue(isBoolean,'Set to True for simple pointers'),

        label_pointer_strokeColor = AttrMapValue(isColorOrNone,desc='Color of indicator line'),

        label_pointer_strokeWidth = AttrMapValue(isNumber,desc='StrokeWidth of indicator line'),

        label_pointer_elbowLength = AttrMapValue(isNumber,desc='Length of final indicator line segment'),

        label_pointer_edgePad = AttrMapValue(isNumber,desc='pad between pointer label and box'),

        label_pointer_piePad = AttrMapValue(isNumber,desc='pad between pointer label and pie'),

        swatchMarker = AttrMapValue(NoneOr(isSymbol), desc="None or makeMarker('Diamond') ...",advancedUsage=1),

        visible = AttrMapValue(isBoolean,'Set to false to skip displaying'),

        )

    def __init__(self):

        self.strokeWidth = 0

        self.fillColor = None

        self.strokeColor = STATE_DEFAULTS["strokeColor"]

        self.strokeDashArray = STATE_DEFAULTS["strokeDashArray"]

        self.strokeLineJoin = 1

        self.strokeLineCap = 0

        self.strokeMiterLimit = 0

        self.popout = 0

        self.fontName = STATE_DEFAULTS["fontName"]

        self.fontSize = STATE_DEFAULTS["fontSize"]

        self.fontColor = STATE_DEFAULTS["fillColor"]

        self.labelRadius = 1.2

        self.label_dx = self.label_dy = self.label_angle = 0

        self.label_text = None

        self.label_topPadding = self.label_leftPadding = self.label_rightPadding = self.label_bottomPadding = 0

        self.label_boxAnchor = 'autox'

        self.label_boxStrokeColor = None    #boxStroke

        self.label_boxStrokeWidth = 0.5 #boxStrokeWidth

        self.label_boxFillColor = None

        self.label_strokeColor = None

        self.label_strokeWidth = 0.1

        self.label_leading =    self.label_width = self.label_maxWidth = self.label_height = None

        self.label_textAnchor = 'start'

        self.label_simple_pointer = 0

        self.label_visible = 1

        self.label_pointer_strokeColor = colors.black

        self.label_pointer_strokeWidth = 0.5

        self.label_pointer_elbowLength = 3

        self.label_pointer_edgePad = 2

        self.label_pointer_piePad = 3

        self.visible = 1

def _addWedgeLabel(self,text,angle,labelX,labelY,wedgeStyle,labelClass=WedgeLabel):

    # now draw a label

    if self.simpleLabels:

        theLabel = String(labelX, labelY, text)

        if not self.sideLabels:

            theLabel.textAnchor = "middle"

        else:

            if (abs(angle) < 90 ) or (angle >270 and angle<450) or (-450< angle <-270):

                theLabel.textAnchor = "start"

            else:

                theLabel.textAnchor = "end"

        theLabel._pmv = angle

        theLabel._simple_pointer = 0

    else:

        theLabel = labelClass()

        theLabel._pmv = angle

        theLabel.x = labelX

        theLabel.y = labelY

        theLabel.dx = wedgeStyle.label_dx

        if not self.sideLabels:

            theLabel.dy = wedgeStyle.label_dy

            theLabel.boxAnchor = wedgeStyle.label_boxAnchor

        else:

            if wedgeStyle.fontSize is None:

                sideLabels_dy = self.fontSize / 2.5

            else:

                sideLabels_dy = wedgeStyle.fontSize / 2.5

            if wedgeStyle.label_dy is None:

                theLabel.dy = sideLabels_dy

            else:

                theLabel.dy = wedgeStyle.label_dy + sideLabels_dy

            if (abs(angle) < 90 ) or (angle >270 and angle<450) or (-450< angle <-270):

                theLabel.boxAnchor = 'w'

            else:

                theLabel.boxAnchor = 'e'

        theLabel.angle = wedgeStyle.label_angle

        theLabel.boxStrokeColor = wedgeStyle.label_boxStrokeColor

        theLabel.boxStrokeWidth = wedgeStyle.label_boxStrokeWidth

        theLabel.boxFillColor = wedgeStyle.label_boxFillColor

        theLabel.strokeColor = wedgeStyle.label_strokeColor

        theLabel.strokeWidth = wedgeStyle.label_strokeWidth

        _text = wedgeStyle.label_text

        if _text is None: _text = text

        theLabel._text = _text

        theLabel.leading = wedgeStyle.label_leading

        theLabel.width = wedgeStyle.label_width

        theLabel.maxWidth = wedgeStyle.label_maxWidth

        theLabel.height = wedgeStyle.label_height

        theLabel.textAnchor = wedgeStyle.label_textAnchor

        theLabel.visible = wedgeStyle.label_visible

        theLabel.topPadding = wedgeStyle.label_topPadding

        theLabel.leftPadding = wedgeStyle.label_leftPadding

        theLabel.rightPadding = wedgeStyle.label_rightPadding

        theLabel.bottomPadding = wedgeStyle.label_bottomPadding

        theLabel._simple_pointer = wedgeStyle.label_simple_pointer

    theLabel.fontSize = wedgeStyle.fontSize

    theLabel.fontName = wedgeStyle.fontName

    theLabel.fillColor = wedgeStyle.fontColor

    return theLabel

def _fixLabels(labels,n):

    if labels is None:

        labels = [''] * n

    else:

        i = n-len(labels)

        if i>0: labels = list(labels)+['']*i

    return labels

class AbstractPieChart(PlotArea):

    def makeSwatchSample(self, rowNo, x, y, width, height):

        baseStyle = self.slices

        styleIdx = rowNo % len(baseStyle)

        style = baseStyle[styleIdx]

        strokeColor = getattr(style, 'strokeColor', getattr(baseStyle,'strokeColor',None))

        fillColor = getattr(style, 'fillColor', getattr(baseStyle,'fillColor',None))

        strokeDashArray = getattr(style, 'strokeDashArray', getattr(baseStyle,'strokeDashArray',None))

        strokeWidth = getattr(style, 'strokeWidth', getattr(baseStyle, 'strokeWidth',None))

        swatchMarker = getattr(style, 'swatchMarker', getattr(baseStyle, 'swatchMarker',None))

        if swatchMarker:

            return uSymbol2Symbol(swatchMarker,x+width/2.,y+height/2.,fillColor)

        return Rect(x,y,width,height,strokeWidth=strokeWidth,strokeColor=strokeColor,

                    strokeDashArray=strokeDashArray,fillColor=fillColor)

    def getSeriesName(self,i,default=None):

        '''return series name i or default'''

        try:

            text = _objStr(self.labels[i])

        except:

            text = default

        if not self.simpleLabels:

            _text = getattr(self.slices[i],'label_text','')

            if _text is not None: text = _text

        return text

def boundsOverlap(P,Q):

    return not(P[0]>Q[2]-1e-2 or Q[0]>P[2]-1e-2 or P[1]>(0.5*(Q[1]+Q[3]))-1e-2 or Q[1]>(0.5*(P[1]+P[3]))-1e-2)

def _findOverlapRun(B,i,wrap):

    '''find overlap run containing B[i]'''

    n = len(B)

    R = [i]

    while 1:

        i = R[-1]

        j = (i+1)%n

        if j in R or not boundsOverlap(B[i],B[j]): break

        R.append(j)

    while 1:

        i = R[0]

        j = (i-1)%n

        if j in R or not boundsOverlap(B[i],B[j]): break

        R.insert(0,j)

    return R

def findOverlapRun(B,wrap=1):

    '''determine a set of overlaps in bounding boxes B or return None'''

    n = len(B)

    if n>1:

        for i in range(n-1):

            R = _findOverlapRun(B,i,wrap)

            if len(R)>1: return R

    return None

def fixLabelOverlaps(L, sideLabels=False):

    nL = len(L)

    if nL<2: return

    B = [l._origdata['bounds'] for l in L]

    OK = 1

    RP = []

    iter = 0

    mult = 1.

    if not sideLabels:

        while iter<30:

            R = findOverlapRun(B)

            if not R: break

            nR = len(R)

            if nR==nL: break

            if not [r for r in RP if r in R]:

                mult = 1.0

            da = 0

            r0 = R[0]

            rL = R[-1]

            bi = B[r0]

            taa = aa = _360(L[r0]._pmv)

            for r in R[1:]:

                b = B[r]

                da = max(da,min(b[3]-bi[1],bi[3]-b[1]))

                bi = b

                aa += L[r]._pmv

            aa = aa/float(nR)

            utaa = abs(L[rL]._pmv-taa)

            ntaa = _360(utaa)

            da *= mult*(nR-1)/ntaa

            for r in R:

                l = L[r]

                orig = l._origdata

                angle = l._pmv = _360(l._pmv+da*(_360(l._pmv)-aa))

                rad = angle/_180_pi

                l.x = orig['cx'] + orig['rx']*cos(rad)

                l.y = orig['cy'] + orig['ry']*sin(rad)

                B[r] = l.getBounds()

            RP = R

            mult *= 1.05

            iter += 1

    else:

        while iter<30:

            R = findOverlapRun(B)

            if not R: break

            nR = len(R)

            if nR == nL: break

            l1 = L[-1]

            orig1 = l1._origdata

            bounds1 = orig1['bounds']

            for i,r in enumerate(R):

                l = L[r]

                orig = l._origdata

                bounds = orig['bounds']

                diff1 = 0

                diff2 = 0

                if not i == nR-1:

                    if not bounds == bounds1:

                        if bounds[3]>bounds1[1] and bounds1[1]<bounds[1]:

                            diff1 = bounds[3]-bounds1[1]

                        if bounds1[3]>bounds[1] and bounds[1]<bounds1[1]:

                            diff2 = bounds1[3]-bounds[1]

                        if diff1 > diff2: 

                            l.y +=0.5*(bounds1[3]-bounds1[1])

                        elif diff2 >= diff1:

                            l.y -= 0.5*(bounds1[3]-bounds1[1])

                    B[r] = l.getBounds()

            iter += 1

def intervalIntersection(A,B):

    x,y = max(min(A),min(B)),min(max(A),max(B))

    if x>=y: return None

    return x,y

def _makeSideArcDefs(sa,direction):

    sa %= 360

    if 90<=sa<270:

        if direction=='clockwise':

            a = (0,90,sa),(1,-90,90),(0,-360+sa,-90)

        else:

            a = (0,sa,270),(1,270,450),(0,450,360+sa)

    else:

        offs = sa>=270 and 360 or 0

        if direction=='clockwise':

            a = (1,offs-90,sa),(0,offs-270,offs-90),(1,-360+sa,offs-270)

        else:

            a = (1,sa,offs+90),(0,offs+90,offs+270),(1,offs+270,360+sa)

    return tuple([a for a in a if a[1]<a[2]])

def _keyFLA(x,y):

    return cmp(y[1]-y[0],x[1]-x[0])

_keyFLA = functools.cmp_to_key(_keyFLA)

def _findLargestArc(xArcs,side):

    a = [a[1] for a in xArcs if a[0]==side and a[1] is not None]

    if not a: return None

    if len(a)>1: a.sort(key=_keyFLA)

    return a[0]

def _fPLSide(l,width,side=None):

    data = l._origdata

    if side is None:

        li = data['li']

        ri = data['ri']

        if li is None:

            side = 1

            i = ri

        elif ri is None:

            side = 0

            i = li

        elif li[1]-li[0]>ri[1]-ri[0]:

            side = 0

            i = li

        else:

            side = 1

            i = ri

    w = data['width']

    edgePad = data['edgePad']

    if not side:    #on left

        l._pmv = 180

        l.x = edgePad+w

        i = data['li']

    else:

        l._pmv = 0

        l.x = width - w - edgePad

        i = data['ri']

    mid = data['mid'] = (i[0]+i[1])*0.5

    data['smid'] = sin(mid/_180_pi)

    data['cmid'] = cos(mid/_180_pi)

    data['side'] = side

    return side,w

#key functions

def _fPLCF(a,b): 

    return cmp(b._origdata['smid'],a._origdata['smid'])

_fPLCF = functools.cmp_to_key(_fPLCF)

def _arcCF(a):

    return a[1]

def _fixPointerLabels(n,L,x,y,width,height,side=None):

    LR = [],[]

    mlr = [0,0]

    for l in L:

        i,w = _fPLSide(l,width,side)

        LR[i].append(l)

        mlr[i] = max(w,mlr[i])

    mul = 1

    G = n*[None]

    mel = 0

    hh = height*0.5

    yhh = y+hh

    m = max(mlr)

    for i in (0,1):

        T = LR[i]

        if T:

            B = []

            aB = B.append

            S = []

            aS = S.append

            T.sort(key=_fPLCF)

            p = 0

            yh = y+height

            for l in T:

                data = l._origdata

                inc = x+mul*(m-data['width'])

                l.x += inc

                G[data['index']] = l

                ly = yhh+data['smid']*hh

                b = data['bounds']

                b2 = (b[3]-b[1])*0.5

                if ly+b2>yh: ly = yh-b2

                if ly-b2<y: ly = y+b2

                data['bounds'] = b = (b[0],ly-b2,b[2],ly+b2)

                aB(b)

                l.y = ly

                aS(max(0,yh-ly-b2))

                yh = ly-b2

                p = max(p,data['edgePad']+data['piePad'])

                mel = max(mel,abs(data['smid']*(hh+data['elbowLength']))-hh)

            aS(yh-y)

            iter = 0

            nT = len(T)

            while iter<30:

                R = findOverlapRun(B,wrap=0)

                if not R: break

                nR = len(R)

                if nR==nT: break

                j0 = R[0]

                j1 = R[-1]

                jl = j1+1

                sAbove = sum(S[:j0+1])

                sFree = sAbove+sum(S[jl:])

                sNeed = sum([b[3]-b[1] for b in B[j0:jl]])+jl-j0-(B[j0][3]-B[j1][1])

                if sNeed>sFree: break

                yh = B[j0][3]+sAbove*sNeed/sFree

                for r in R:

                    l = T[r]

                    data = l._origdata

                    b = data['bounds']

                    b2 = (b[3]-b[1])*0.5

                    yh -= 0.5

                    ly = l.y = yh-b2

                    B[r] = data['bounds'] = (b[0],ly-b2,b[2],yh)

                    yh = ly - b2 - 0.5

            mlr[i] = m+p

        mul = -1

    return G, mlr[0], mlr[1], mel

def theta0(data, direction):

    fac = (2*pi)/sum(data)

    rads = [d*fac for d in data]

    r0 = 0

    hrads = []

    for r in rads:

        hrads.append(r0+r*0.5)

        r0 += r

    vstar = len(data)*1e6

    rstar = 0