from lxml import etree

import math

import collections

from collections import Counter

from collections import OrderedDict

import numpy as np

from singlecellmultiomics.utils import bdbbio

import os

import matplotlib.cm

from Bio import SeqIO

from Bio.Seq import Seq

import matplotlib.pyplot as plt

from colorama import Fore #,Back, Style

from colorama import Back

from colorama import Style

from colorama import init

import scipy

import scipy.cluster

import time

import itertools

init(autoreset=True)

#Convert a nested dictionary to a matrix

# ({'A':{'1':2}, 'B':{'1':3, '2':4}}) will become

#(array([[  2.,  nan],

#        [  3.,   4.]]), ['A', 'B'], ['1', '2'])

def interpolateBezier( points, steps=10, t=None):

    if len(points)==3:

        mapper = lambda t,p: (1-t)**2 * p[0] + 2*(1-t)*t*p[1] + t**2*p[2]

    elif len(points)==4:

        mapper = lambda t,p: (np.power( (1-t),3)*p[0] +\

         3* np.power((1-t),2) *t *p[1] +\

         3*(1-t)*np.power(t,2)*p[2] +\

         np.power(t,3)*p[3])

    if t is not None:

        return   mapper(t, [q[0] for q in points]), mapper(t, [q[1] for q in points])

    xGen = ( mapper(t, [q[0] for q in points]) for t in np.linspace(0, 1, steps) )

    yGen = ( mapper(t, [q[1] for q in points]) for t in np.linspace(0, 1, steps) )

    return zip(xGen, yGen)

def interpolateBezierAngle(points, t, ds=0.001):

    x0, y0 = interpolateBezier(points, t=t-ds)

    x1, y1 = interpolateBezier(points, t=t+ds)

    return np.arctan2( y1-y0, x0-x1)

def initMatrix(rowNames,columnNames, mtype="obj"):

    if mtype=="obj":

        matrix = np.empty( (len(rowNames), len(columnNames)), dtype=object)

    elif mtype=="npzeros":

        matrix = np.zeros( (len(rowNames), len(columnNames)))

    return(matrix)

def nestedDictionaryToNumpyMatrix( nestedDictionary, setNan=True, mtype="obj", transpose=False, indicateProgress=False):

    rowNames = sorted( list(nestedDictionary.keys()), key=int )

    columnNames = set()

    for key in nestedDictionary:

        columnNames.update( set(nestedDictionary[key].keys() ))

    columnNames = sorted( list(columnNames) )

    keys = list(columnNames)

    if ':' in keys[0]:

        sargs = np.argsort( [ int(k.split(':')[1]) for k in keys] )

        print(sargs)

        columnNames = [ keys[index] for index in sargs ]

        print(columnNames)

    matrix = initMatrix(rowNames,columnNames, mtype)

    if setNan:

        matrix[:] = np.nan

    prevTime = time.time()

    for rowIndex,rowName in enumerate(rowNames):

        if indicateProgress and (time.time()-prevTime)>1:

            prevTime = time.time()

            print("Matrix creation progress: %.2f%%" % (100.0*rowIndex/len(rowNames)))

        for colIndex,colName in enumerate(columnNames):

            try:

                matrix[rowIndex,colIndex] = nestedDictionary[rowName][colName]

            except:

                pass

    if transpose:

        matrix = matrix.transpose()

        columnNames, rowNames =  rowNames, columnNames

    if indicateProgress:

        print("Matrix finished")

    return( (matrix, rowNames, columnNames) )

def pruneNonUniqueColumnsFromMatrix(matrix,rows,columns, minInstances=1,minOccurence=1):

    colsToKeep = []

    for columnIndex in range(matrix.shape[1]):

        if len( set(np.unique( matrix[:,columnIndex].astype(str) ))-set( ["nan"]) )>minInstances:

            cnts = Counter( list(matrix[:,columnIndex].astype(str)) )

            counts = Counter({k: cnts[k] for k in  cnts if cnts[k] >= minOccurence})

            del counts['nan']

            if len(counts.values())>minInstances:

                colsToKeep.append(columnIndex)

    matrix = matrix[:,colsToKeep]

    columns = np.array(columns)[colsToKeep]

    return(matrix, rows, columns)

# Convert dictionary of tuples to a numpy matrix

def tupleAnnotationsToNumpyMatrix( originRowNames, originColNames, tuples, setNan=True, mtype="obj" ):

    m = initMatrix(originRowNames,originColNames, mtype) #np.zeros( (len(originRowNames), len(originColNames)))

    if setNan:

        m[:] = np.nan

    for tup in tuples:

        value = tuples[tup]

        if tup[0] in originRowNames and tup[1] in originColNames:

         m[originRowNames.index(tup[0]), originColNames.index(tup[1])  ] = value

    return(m)

def dictAnnotationsToNumpyMatrix( originRowNames, originColNames, dictionary, mtype="obj" ):

    tuples = {}

    for rowKey in dictionary:

        for columnKey in dictionary[rowKey]:

            tuples[ (rowKey, columnKey) ] = dictionary[rowKey][columnKey]

    return(tupleAnnotationsToNumpyMatrix(originRowNames, originColNames, tuples, mtype=mtype))

def getSomeColors(n):

    return( plt.cm.Set1(np.linspace(0, 1, n)) )

def _ipol(a, b, first, last,  interpolateValue):

    #Due to floating point rounding errors the interpolate value can be very close to last,

    # it is ok to return last in those cases

    if last>first and interpolateValue>=last:

        return(b)

    if last<first and interpolateValue>=first:

        return(a)

    y_interp = scipy.interpolate.interp1d([first, last], [a,b])

    return( y_interp(interpolateValue) )

def interpolate(interpolateValue,  colorScaleKeys, nodeColorMapping):

        #Seek positions around value to interpolate

        first = colorScaleKeys[0]

        index = 0

        last = first

        for value in colorScaleKeys:

            if value>=interpolateValue:

                last = value

                break

            else:

                first = value

            index+=1

        if value==interpolateValue:

            return(nodeColorMapping[value])

        #Do interpolation

        colorA = nodeColorMapping[first]

        colorB = nodeColorMapping[last]

        dx = last-first

        # Check out of bounds condition

        if interpolateValue< first:

            return(colorA)

        if interpolateValue>last:

            return(colorB)

        return( _ipol(colorA[0], colorB[0], first, last, interpolateValue), _ipol(colorA[1], colorB[1], first, last, interpolateValue), _ipol(colorA[2], colorB[2], first, last, interpolateValue))

def plotFeatureSpace(features, classLabels, featureNames, path=None, bins = 50, title=None):

    print(Fore.GREEN + "Feature space plotter:")

    #1d mode:

    print(features.shape)

    classAbundance = Counter(classLabels)

    print(classAbundance)

    classes = set(classLabels)

    classColors = ['#FF6A00','#0066FF','#FF33FF','#666666']

    classColors = [ tuple(float(int(hexColor.replace('#','')[i:i+2], 16))/255.0 for i in (0, 2 ,4)) for hexColor in classColors]

    if features.shape[1]==1:

        print("Performing 1-D density plot of %s samples" % ( features.shape[0]))

        plt.close('all')

        histStart = features.min()

        histEnd = features.max()

        if histStart == histEnd:

            histEnd += 1

            histStart -= 1

        precision = (histEnd-histStart)/bins

        print("Histogram will be plotted from %s to %s " % (histStart, histEnd))

        fig, ax = plt.subplots() #figsize=(120, 10))

        print(classColors)

        for classIndex,className in enumerate(list(classes)):

            boolList = np.array(classLabels)==np.array(className)

            classSize = classAbundance[className]

            ax.hist(

                features[boolList,0],

                np.arange(histStart,histEnd+precision,precision),

                normed=False, fc= (classColors[classIndex]+ (0.5,)),

                ec=classColors[classIndex],

                lw=1.5, histtype='stepfilled',

                label='%s[%s]' % (className,classSize)

                )

        plt.ylabel("Density")

        plt.xlabel(featureNames[0])

        if title is not None:

            plt.title(title)

        ax.legend(loc='upper right')

        #plt.yscale('log', nonposy='clip')

        if path is None:

            plt.show()

        else:

            plt.savefig(path)

        return(True)

    if features.shape[1]==2:

        #2d

        print("Performing 2-D density plot of %s samples" % ( features.shape[0]))

        fig, ax = plt.subplots()

        for classIndex,className in enumerate(list(classes)):

            #print(np.where( classLabels==className, features ))

            boolList = np.array(classLabels)==np.array(className)

            plt.plot( features[boolList,0], features[boolList,1], ".",label='%s[%s]' % (className,sum(boolList)), c= (classColors[classIndex] + (0.5,)))

        plt.xlabel(featureNames[0])

        plt.ylabel(featureNames[1])

        plt.legend(loc="lower right")

        plt.tight_layout()

        try:

            plt.savefig(path)

        except Exception as e:

            print(e)

        return(True)

    print(Fore.RED + "Invalid amount of dimensions for feature space plotting (%s)" % features.shape[1])

def matplotHeatmap( D, YC, figsize=(10,10), clust=True, xLab=None, yLab=None, show=True, colormap=plt.cm.YlGnBu_r, colorbarLabel=None ):

    plt.rcParams["axes.grid"] = False

    import scipy

    import scipy.cluster.hierarchy as sch

    # Compute and plot first dendrogram.

    fig = plt.figure(figsize=figsize)

    if not clust:

        idx1 = range(0, len(YC))

        idx1 = range(0, len(YC))

    if clust:

        ax1 = fig.add_axes([0.09,0.1,0.2,0.6])

        L = sch.linkage(D, method='centroid')

        Z1 = sch.dendrogram(L, orientation='right')

        ax1.set_xticks([])

        ax1.set_yticks([])

        # Compute and plot second dendrogram.

        ax2 = fig.add_axes([0.3,0.71,0.6,0.2])

        Z2 = sch.dendrogram(L)

        ax2.set_xticks([])

        ax2.set_yticks([])

        idx1 = Z1['leaves']

        idx2 = Z2['leaves']

        D = D[idx1,:]

        D = D[:,idx1]

    # Plot distance matrix.

    axmatrix = fig.add_axes([0.3,0.1,0.6,0.6])

    im = axmatrix.matshow(D, aspect='auto', origin='lower', cmap=colormap)

    axmatrix.set_xticks([])

    axmatrix.set_yticks([])

    ###

    if xLab is None:

        axmatrix.set_xticks(range(len(YC)))

        axmatrix.set_xticklabels(YC[idx1])

    else:

        axmatrix.set_xticks(range(len(xLab)))

        axmatrix.set_xticklabels(xLab)

    axmatrix.xaxis.set_label_position('bottom')

    axmatrix.xaxis.tick_bottom()

    plt.xticks(rotation=-90)

    if yLab is None:

        axmatrix.set_yticks(range(len(YC)))

        axmatrix.set_yticklabels(YC[idx1], minor=False)

    else:

        axmatrix.set_yticks(range(len(yLab)))

        axmatrix.set_yticklabels(yLab, minor=False)

    axmatrix.yaxis.set_label_position('right')

    axmatrix.yaxis.tick_right()

    # Plot colorbar.

    axcolor = fig.add_axes([1.05,0.1,0.02,0.6])

    cbar = fig.colorbar(im, cax=axcolor)

    if colorbarLabel is not None:

        cbar.set_label(colorbarLabel, rotation=270,  labelpad=15)

    if show:

        fig.savefig('dendrogram.png')

def tsnePlot(data, labels=None, components=2, perplexity=30.0, iterations=1000):

    from sklearn.manifold import TSNE

    #from MulticoreTSNE import MulticoreTSNE as TSNE

    model = TSNE(n_components=components, perplexity=perplexity, n_iter=iterations ) #random_state=0, n_jobs=8,

    transformedPoints = model.fit_transform(data.astype(np.float64))

    classes = list(set(labels))

    classColors = getSomeColors(len(classes))

    color = np.array([ classColors[classes.index(label)] for label in labels ])

    nplabels = np.array(labels)

    print("TSNE input:")

    print(data.shape)

    print("TSNE plotting for %s classes " %  len(classes))

    #print("Color mapping is %s" % ",".join(color))

    #Plot the data:

    if components==2:

        fig = plt.figure()

        #plt.style.use('ggplot')

        ax = fig.add_subplot(111)

        print(color)

        #plt.scatter(transformedPoints[:, 0], transformedPoints[:, 1], c=color, cmap=plt.cm.Spectral, s=1, alpha=0.5) #labels=labels,

        for classIndex, className in enumerate(classes):

            classColor = classColors[classIndex]

            print(className)

            print(classColor)

            plt.scatter(transformedPoints[className==nplabels, 0], transformedPoints[className==nplabels, 1],   s=3, alpha=0.9, label=className)  #c=classColor,, cmap=plt.cm.Spectral,

        #plt.axis('tight')

        box = ax.get_position()

        ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])

        # Put a legend to the right of the current axis

        ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))

        plt.show()

    elif components==3:

        from mpl_toolkits.mplot3d import Axes3D

        fig = plt.figure()

        ax = fig.add_subplot(111, projection='3d')

        for classIndex,className in enumerate(classes):

            samplesForClass = (className==nplabels)

            ax.scatter(transformedPoints[samplesForClass,0], transformedPoints[samplesForClass,1], transformedPoints[samplesForClass,2], c=classColors[classIndex], label=classIndex)

        ax.legend()

        plt.show()

class BDBcolor():

    def __init__(self, r=0, g=0, b=0, a=1.0 ):

        if str(r)[0]=='#':

            #parse hex colour:

            #parts = r.replace('#','').replace('(','').replace(')','').split(',')

            cleaned = r.replace('#','')

            #parts = [int(i) for i in parts]

            r =  int(cleaned[0:2], 16)

            g =  int(cleaned[2:4], 16)

            b =  int(cleaned[4:6], 16)

        self.r = max(0,min(255,r))

        self.g = max(0,min(255,g))

        self.b = max(0,min(255,b))

        self.a = max(0,min(1.0,a))

    def getRGBStr(self):

        return('rgb(%s,%s,%s)' % (int(self.r), int(self.g), int(self.b)))

    def getRGBAStr(self):

        return('rgba(%s,%s,%s,%s)' % (self.r, self.g, self.b, self.a))

    def getReadableInverted(self):

        hsv = self.getHSV()

        hsv['v'] = (  255.0-( hsv['v'] ) )

        rgb = self.HSVtoRGB(0,0,hsv['v'])

        return( BDBcolor( rgb['r'],rgb['g'],rgb['b'] ))

    def getHSV(self):

        h=0

        s=0

        v=0

        minV = min( self.r, self.g, self.b )

        maxV = max( self.r, self.g, self.b )

        v = maxV

        delta = maxV - minV

        if maxV != 0:

            s = delta / float(maxV)

        else:

            s = 0

            h = -1

            return({'h':h, 's':s, 'v':v})

        if delta==0:

                h = 255

        else:

                if self.r == maxV:

                    h = ( self.g - self.b ) / float(delta)

                else:

                        if self.g == maxV:

                                h = 2.0 + float( self.b - self.r ) / float(delta)

                        else:

                                h = 4.0 + float( self.r - self.g ) / float(delta)

        h *= 60

        if h < 0:

            h += 360

        return({'h':h, 's':s, 'v':v})

    def HSVtoRGB( self, h,s,v ):

        i=0

        f=0

        p=0

        q=0

        t = 0

        if s == 0:

            #Grey

            r = g = b = v

            return({'r':round(r), 'g':round(g), 'b':round(b)})

        h /= 60         # sector 0 to 5

        i = math.floor( h )

        f = h - i           # factorial part of h

        p = v * ( 1 - s )

        q = v * ( 1 - s * f )

        t = v * ( 1 - s * ( 1 - f ) )

        if i==0:

            r = v

            g = t

            b = p

        elif i==1:

            r = q

            g = v

            b = p

        elif i==2:

            r = p

            g = v

            b = t

        elif i==3:

            r = p

            g = q

            b = v

        elif i==4:

            r = t

            g = p

            b = v

        else:

            r = v

            g = p

            b = q

        return({'r':round(r), 'g':round(g), 'b':round(b)})

class BDBPlot():

    def __init__(self):

        # We need to declare the xlink namespace, to create references to things in our own file

        self.xlink =  'http://www.w3.org/1999/xlink'

        NSMAP = {'xlink':self.xlink }

        self.svgTree = etree.Element('svg',nsmap = NSMAP)

        self.svgTree.set('xmlns','http://www.w3.org/2000/svg')

        self.svgTree.set('version','1.2')

        self.root = self.svgTree.getroottree()

        self.nextFilterId = 0

        self.nextObjId = 0

        self.nextTspanId = 0

        #Create definition element

        self.svgTree.append( self.getDefinitionBlock() )

        self.debug = 2 # 2 all

        self.xMin = 0

        self.xMax = 10

        self.yMin = 0

        self.yMax = 10

        self.plotStartX = 30

        self.plotStartY = 30

        self.plotHeight = 400

        self.plotWidth = 600

        self.setWidth(800)

        self.setHeight(1000)

        self.script = ""

    def clear(self):

        toRm = []

        for child in self.svgTree:

            toRm.append(child)

        for child in toRm:

            self.svgTree.remove(child)

        self.svgTree.append( self.getDefinitionBlock() )

        self.nextFilterId = 0

        self.nextObjId = 0

    def getGroup(self, identifier, zIndex=0 ):

        g = etree.Element('g')

        g.set('id', str(identifier))

        self.svgTree.append(g)

        return(g)

    def getTspan(self):

        tspan = etree.Element('tspan')

        tspan.set('id', str(self.nextTspanId))

        self.nextTspanId+=1

        return(tspan)

    def addLegend(self,colorMapping):

        y = 0

        c = self.getYLabelCoord(y)

        yp = c[1]+10 + 80

        for color in colorMapping:

            text = self.getText(str(colorMapping[color]), c[0]+self.plotStartX, yp,BDBcolor(80,80,80,1))

            text.set('text-anchor','begin')

            text.set('dominant-baseline','middle')

            text.set('font-family','Cambria Math')

            text.set('fill','%s' % color)

            self.svgTree.append( text )

            yp+=20

    def getGroupColors(self, n):

        if n==1:

            return(['#3770C4'])

        if n==2:

            return(['#3770C4','#66A43E'])

        if n==3:

            return(['#3770C4','#66A43E','#F6853A'])

        if n==4:

            return(['#3770C4','#A43E3E','#66A43E','#F6853A'])

        if n==5:

            return(['#3770C4','#A43E3E','#66A43E','#F6853A','#A33DA2'])

        if n==6:

            return(['#3770C4','#A43E3E','#66A43E','#F6853A','#A33DA2','#AAD400'])

        if n==7:

            return(['#3770C4','#A43E3E','#66A43E','#F6853A','#A33DA2','#AAD400','#9DAC93'])

        if n==8:

            return(['#3770C4','#A43E3E','#66A43E','#F6853A','#A33DA2','#AAD400','#9DAC93','#7FCADF'])

        if n==9:

            return(['#3770C4','#A43E3E','#66A43E','#F6853A','#A33DA2','#AAD400','#9DAC93','#7FCADF','#D1AC17'])

        return(['#3770C4','#A43E3E','#66A43E','#F6853A','#A33DA2','#AAD400','#9DAC93','#7FCADF','#D1AC17','#000080','#FF0066','#6C5D53'] + ['#333333']*n)

    #Macro to set a title quickly

    def setTitle(self, string, x=None, y=10, size=25, fill='#333333' ):

        centerX = x is None

        if x is None:

            x,_= self.getPlottingCoord(self.xMin + 0.5*(self.xMax - self.xMin), 0)

        text = self.getText(str(string), x,y, fill=fill)

        if centerX:

            text.set('text-anchor','middle')

        else:

            text.set('text-anchor','begin')

        text.set('dominant-baseline','central')

        text.set('font-family','Gill Sans MT')

        text.set('font-size', str(size))

        self.svgTree.append(text)

        return(self)

    def setSubtitle(self, string, x=None, y=40, size=15, fill='#222222'):

        self.setTitle(string,x,y,size,fill)

    def setWidth(self, width):

        self.width = width

        self.svgTree.set('width','%s' % width)

    def setHeight(self, height):

        self.height = height

        self.svgTree.set('height','%s' % height)

    def getDx(self):

        return( float(self.plotWidth )/float((self.xMax - self.xMin)))

    def getDy(self):

        return( float(self.plotHeight )/float((self.yMax - self.yMin)))

    def getPlottingCoord(self, x,y,z=0):

        return( (self.plotStartX + (float(x)/(self.xMax - self.xMin))*self.plotWidth, self.plotHeight+self.plotStartY -(( float(y)/(self.yMax - self.yMin)))*self.plotHeight))

    def getXLabelCoord(self, x):

        return( (self.plotStartX + (float(x)/(self.xMax - self.xMin))*self.plotWidth, self.plotHeight+self.plotStartY+2 ))

    def getYLabelCoord(self, y):

        return( (self.plotStartX, self.plotHeight+self.plotStartY -(( float(y)/(self.yMax - self.yMin)))*self.plotHeight ))

    def getNextObjId(self):

        self.nextObjId+=1

        return(str(self.nextObjId))

    def getDefinitionBlock(self):

        self.defs = etree.Element('defs')

        self.defs.set('id','defs0')

        return(self.defs)

    def filter(self):

        filterDef = etree.Element('filter')

        filterDef.set('id','filter_%s' % (self.nextFilterId))

        self.nextFilterId+=1

        return(filterDef)

    def getAxis(self,hv=0):

        if hv==1:

            p = self.getPath(self.getPathDefinition([self.getPlottingCoord(self.xMin, self.yMin), self.getPlottingCoord(self.xMax, self.yMin)]))

        elif hv==2:

            p = self.getPath(self.getPathDefinition([self.getPlottingCoord(self.xMin, self.yMax),self.getPlottingCoord(self.xMin, self.yMin)]))

        else:

            p = self.getPath(self.getPathDefinition([self.getPlottingCoord(self.xMin, self.yMax),self.getPlottingCoord(self.xMin, self.yMin), self.getPlottingCoord(self.xMax, self.yMin)]))

        return(p)

    def getPathDefinition(self, coordinates, preventAliasing=False ):

        definition = []

        for idx,coordinateTuple in enumerate(coordinates):

            if preventAliasing:

                coordinateTuple = ( round(coordinateTuple[0])+0.5, round(coordinateTuple[1])+0.5 )

            if idx==0:

                definition.append('M%s,%s' % (coordinateTuple[0],coordinateTuple[1]))

            else:

                definition.append('L%s,%s' % (coordinateTuple[0],coordinateTuple[1]))

        return(' '.join(definition))

    def getLinearGradientDefinition(self, tuplesWithStops): #Format: %x, color

        definitionElement =  etree.Element('linearGradient')

        definitionElement.set('id', self.getNextObjId()) #not really needed

        definitionElement.set('x1', tuplesWithStops[0][0])

        definitionElement.set('y1', tuplesWithStops[0][0])

        definitionElement.set('x2', tuplesWithStops[-1][0])

        definitionElement.set('y2', tuplesWithStops[-1][0])

        for i, tup in enumerate(tuplesWithStops):

            stop = etree.SubElement(definitionElement, 'stop')

            stop.set('offset',tup[0])

            stop.set('stop-color',tup[1])

            if i==0:

                stop.set('class','start')

        stop.set('class','stop')

        return(definitionElement)

    def shadow(self, dy=2, dx=2, gaussStd=2,color='rgb(0,0,0)', floodOpacity=0.9,

     width=None, # Width: set a pixel region around the filter to prevent clipping (https://stackoverflow.com/questions/17883655/svg-shadow-cut-off)

     height=None):

        f = self.filter()

        if width is not None:

            f.set('width', str(width))

            f.set('x', '-%s' % (width*0.5))

        if height is not None:

            f.set('height', str(height))

            f.set('y', '-%s' % (height*0.5))

        f.set('color-interpolation-filters','sRGB')

        self.nextFilterId+=1

        #Flood

        flood = etree.SubElement(f, 'feFlood')

        flood.set('result','flood')

        flood.set('flood-color',color)

        flood.set('flood-opacity','%s' % floodOpacity)

        #Composite filter

        composite1 = etree.SubElement(f, 'feComposite')

        composite1.set('in2','SourceGraphic')

        composite1.set('operator','in')

        composite1.set('in','flood')

        composite1.set('result','composite1')

        #Gaussian blur

        gauss = etree.SubElement(f, 'feGaussianBlur')

        gauss.set('result','blur')

        gauss.set('stdDeviation','%s' % gaussStd)

        #Shadow offset

        offset = etree.SubElement(f, 'feOffset')

        offset.set('result','offset')

        offset.set('dy','%s' % dy)

        offset.set('dx','%s' % dx)

        #Final composite filter

        composite2 = etree.SubElement(f, 'feComposite')

        composite2.set('in2','offset')

        composite2.set('operator','over')

        composite2.set('in','SourceGraphic')

        composite2.set('result','composite2')

        return(f)

    def makeInnerShadow(self, shadow ):

        i = etree.SubElement(shadow, 'feComposite')

        i.set('operator','in')

        i.set('in2','SourceGraphic')

    def addDef(self, filterDef, defId=None):

        if defId is not None:

            filterDef.set('id',defId)

        self.defs.append(filterDef)

        return( filterDef.get('id') )

    def hasDef(self, defId):

        return( len(self.defs.findall(".//*[@id='%s']" % defId))>0 )

    def getDef(self,defId):

        if not self.hasDef(defId):

            print(('Definition %s was not found' % defId))

            exit()

        return( self.defs.findall(".//*[@id='%s']" % defId)[0] )

    def warn(self, msg):

        print(('[WARN] %s' % msg))

    def getRectangle(self, x,y, width, height):

        rectangle = etree.Element('rect')

        rectangle.set('id', self.getNextObjId())

        rectangle.set('x',str(x))

        rectangle.set('y',str(y))

        rectangle.set('width',str(width))

        rectangle.set('height',str(height))

        rectangle.set('style',"fill:rgba(100,100,100,1);stroke:#1b1b1b")

        return(rectangle)

    def getImage( self, path, x=None, y=None, width=None, height=None, preserveAspectRatio=None):

        image = etree.Element('image')

        image.set('id', self.getNextObjId())

        if x is not None:

            image.set('x',str(x))

        if y is not None:

            image.set('y',str(y))

        if width is not None:

            image.set('width',str(width))

        if preserveAspectRatio is not None:

            image.set('preserveAspectRatio',str(preserveAspectRatio))

        if height is not None:

            image.set('height',str(height))

        image.set('{%s}href'% self.xlink ,str(path))

        return(image)

    #Modify attribute in style

    def modifyStyleString(self, style, setAttr={},remove=[]):

        attributes = {}

        if style is not None and style.strip()!='':

            parts = style.split(';')

            for part in parts:

                kvPair = part.split(':')

                if len(kvPair)==2:

                    key = kvPair[0]

                    value = kvPair[1]

                    if key not in remove:

                        attributes[kvPair[0]] = kvPair[1]

                else:

                    self.warn('Style parsing %s failed (ignoring)' % part)

            if self.debug>=3:

                print('Style decomposition')

                for key in attributes:

                    print(('%s\t:\t%s' % (key, attributes[key]) ))

        #Roll changes:

        for attribute in setAttr:

            attributes[attribute] = setAttr[attribute]

        #Create new style string

        newStyle = []

        for attr in attributes:

            newStyle.append('%s:%s' % (attr, attributes[attr]))

        return(';'.join(newStyle))

    def modifyStyle(self, element,setAttr={},remove=[]):

        if not 'style' in element.attrib:

            element.set('style','')

        element.set('style', self.modifyStyleString(element.get('style'), setAttr, remove ))

    def setTextRotation(self, element, angle ):

        element.set('transform','rotate(%s, %s, %s)'%(angle,element.get('x'), element.get('y')))

    def humanReadable(self, value, targetDigits=2,fp=0):

        #Float:

        if value<1 and value>0:

            return('%.2f' % value )

        if value == 0.0:

            return('0')

        baseId = int(math.floor( math.log10(float(value))/3.0 ))

        suffix = ""

        if baseId==0:

            sVal =  str(round(value,targetDigits))

            if len(sVal)>targetDigits and sVal.find('.'):

                sVal = sVal.split('.')[0]

        elif baseId>0:

            sStrD = max(0,targetDigits-len(str( '{:.0f}'.format((value/(math.pow(10,baseId*3)))) )))

            sVal = ('{:.%sf}' % min(fp, sStrD)).format((value/(math.pow(10,baseId*3))))

            suffix = 'kMGTYZ'[baseId-1]

        else:

            sStrD = max(0,targetDigits-len(str( '{:.0f}'.format((value*(math.pow(10,-baseId*3)))) )))

            sVal = ('{:.%sf}' %  min(fp, sStrD)).format((value*(math.pow(10,-baseId*3))))

            suffix = 'mnpf'[-baseId-1]

            if len(sVal)+1>targetDigits:

                # :(

                sVal = str(round(value,fp))[1:]

                suffix = ''

        return('%s%s' % (sVal,suffix))

    def getText(self, text, x=0, y=0, fill=BDBcolor(), pathId=None):

        textElement =  etree.Element('text')

        textElement.set('id', self.getNextObjId())

        if pathId != None:

            tp =  etree.Element('textPath')

            tp.text = text

            tp.set('{%s}href'%self.xlink,  '#%s' % (pathId))

            tp.set("startOffset", "50%")

            textElement.append(tp)

        else:

            textElement.text = str(text)

        textElement.set('x',str(x))

        textElement.set('y',str(y))

        if type(fill) is str:

            textElement.set('fill',fill)

        else:

            textElement.set('fill',fill.getRGBStr())

        textElement.set('shape-rendering','crispEdges')

        return(textElement)

    def getCenteredText(self,text, x,y, bold=False, fontSize=14, fill='rgba(50,50,50,1)', **kwargs):

        text = self.getText(text,x,y,**kwargs)

        text.set('text-anchor','middle')

        text.set('dominant-baseline','middle')

        text.set('font-family','Helvetica')

        #text.set('font-family','Cambria Math')

        if bold:

            text.set('font-weight', 'bold')

        text.set('font-size', str(fontSize))

        text.set('fill', fill)

        return text

    def addTspan(self, textObject, text=None):

        tspan = self.getTspan()

        textObject.append(tspan)

        #Fill with text if supplied:

        if text is not None:

            tspan.text = text

        return(tspan)

    #superscript

    def addSuper(self, text, superText, offset=-10):

        superElement =  etree.Element('tspan')

        superElement.text = superText

        superElement.set('dy', '%s' % offset)

        text.append(superElement)

    def polarToCartesian(self, centerX, centerY, radius, angleInDegrees = None, angleInRadians = None):

        angleInRadians = (angleInDegrees-90) * math.pi / 180.0 if angleInDegrees is not None else angleInRadians

        return({

          'x': centerX + (radius * math.cos(angleInRadians)),

          'y': centerY + (radius * math.sin(angleInRadians))

        })

    def describeArc(self, x, y, radius, startAngle, endAngle, sweep=0, largeArcFlag=None):

        start = self.polarToCartesian(x, y, radius, endAngle)

        end = self.polarToCartesian(x, y, radius, startAngle)

        if largeArcFlag==None:

            if endAngle - startAngle <= 180:

                largeArcFlag  = "0"

            else:

                largeArcFlag  = "1"

        d = " ".join([str(x) for x in [

            "M", start['x'], start['y'],

            "A", radius, radius, 0, largeArcFlag, sweep, end['x'], end['y']

        ]])

        return(d)

    def describeArcRad(self, x, y, radius, startAngle, endAngle, sweep=0, largeArcFlag=None):

        start = self.polarToCartesian(x, y, radius, angleInRadians=startAngle )

        end = self.polarToCartesian(x, y, radius, angleInRadians=endAngle  )

        if largeArcFlag==None:

            if endAngle - startAngle <= math.pi:

                largeArcFlag  = "0"

            else:

                largeArcFlag  = "1"

        d = " ".join([str(x) for x in [

            "M", start['x'], start['y'],

            "A", radius, radius, 0, largeArcFlag, sweep, end['x'], end['y']

        ]])

        return(d)

    def getCircle(self, centerX, centerY, radius):

        circle = etree.Element('circle')

        circle.set('id', self.getNextObjId())

        circle.set('cx',str(centerX))

        circle.set('cy',str(centerY))

        circle.set('r',str(radius))

        circle.set('style',"fill:none;stroke:#1b1b1b;stroke-width:1.29999995;stroke-linecap:round;stroke-miterlimit:4;stroke-opacity:1;stroke-dasharray:5.2, 5.2;stroke-dashoffset:0")

        return(circle)

    def getPath(self, pathDef):

        path = etree.Element('path')

        path.set('id', self.getNextObjId())

        path.set('d', pathDef)

        path.set('style',"fill:none;stroke:#1b1b1b;stroke-width:1;stroke-linecap:round")

        return(path)

    def dump(self):

        print(( etree.toString(self.root, pretty_print=True)))

    def write(self, path, pretty=False, htmlCallback=None, bodyCallback=None):

        try:

            os.makedirs(os.path.dirname(path),exist_ok=True)

        except:

            pass

        if len(self.script)>0:

            html = etree.Element('html')

            head = etree.Element('head')

            body = etree.Element('body')

            s = etree.Element('script')

            s.set('type','text/javascript')

            s.text = self.script

            jquery = etree.Element('script')

            jquery.set('src','https://ajax.googleapis.com/ajax/libs/jquery/2.2.3/jquery.min.js')

            jquery.text = ' '

            head.append(jquery)

            jqueryUi = etree.Element('link')

            jqueryUi.set('rel', 'stylesheet')

            jqueryUi.set('href','https://ajax.googleapis.com/ajax/libs/jqueryui/1.12.1/themes/smoothness/jquery-ui.css')

            jqueryUi.text = ' '

            head.append(jqueryUi)

            jqueryUi = etree.Element('script')

            jqueryUi.set('src','https://ajax.googleapis.com/ajax/libs/jqueryui/1.12.1/jquery-ui.min.js')

            jqueryUi.text = ' '

            head.append(jqueryUi)

            jqueryColor = etree.Element('script')

            jqueryColor.set('src','http://code.jquery.com/color/jquery.color-2.1.2.js')

            jqueryColor.text = ' '

            head.append(jqueryColor)

            body.append(self.svgTree)

            html.append(head)

            body.append(s)

            if htmlCallback is not None:

                htmlCallback(html)

            if bodyCallback is not None:

                bodyCallback(body)

            html.append(body)

            import html as pyhtml

            if pretty:

                import xml.dom.minidom as minidom

                with open(path, 'w') as f:

                    f.write( pyhtml.unescape(minidom.parseString(etree.tostring(html.getroottree())).toprettyxml(indent=" ").decode('utf-8') ))

            else:

                #html.getroottree().write(path)

                with open(path, 'w') as f:

                    f.write( pyhtml.unescape( etree.tostring(html.getroottree()).decode('utf-8') ) )

        else:

            try:

                self.svgTree.getroottree().write(path)

            except:

                print("failed saving %s" % path)

        return(path)

    def SVGtoPNG(self,svgPath, pngPath, width=None, inkscapePath="C:\Program Files (x86)\Inkscape\inkscape.exe"):

        if width is not None:

            pass

        else:

            width = self.width

        #cmd = '"%(INKSCAPE_PATH)s" -z --verb=org.ekips.filter.embedimage --verb=FileSave --verb=FileClose -f %(source_svg)s -w %(width)s -j -e %(dest_png)s' %  {'INKSCAPE_PATH':inkscapePath, 'source_svg':svgPath, 'dest_png':pngPath, 'width':width}

        cmd = '"%(INKSCAPE_PATH)s" -z  --verb=FileSave --verb=FileClose -f %(source_svg)s -w %(width)s -e %(dest_png)s' %  {'INKSCAPE_PATH':inkscapePath, 'source_svg':svgPath, 'dest_png':pngPath, 'width':width}

        os.system('%s' % cmd)

        os.system('%s' % cmd)