#Copyright ReportLab Europe Ltd. 2000-2012

#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/lib/colors.py

__version__=''' $Id$ '''

__doc__='''Defines standard colour-handling classes and colour names.

We define standard classes to hold colours in two models:  RGB and CMYK.

These can be constructed from several popular formats.  We also include

- pre-built colour objects for the HTML standard colours

- pre-built colours used in ReportLab's branding

- various conversion and construction functions

These tests are here because doctest cannot find them otherwise.

>>> toColor('rgb(128,0,0)')==toColor('rgb(50%,0%,0%)')

True

>>> toColor('rgb(50%,0%,0%)')!=Color(0.5,0,0,1)

True

>>> toColor('hsl(0,100%,50%)')==toColor('rgb(255,0,0)')

True

>>> toColor('hsl(-120,100%,50%)')==toColor('rgb(0,0,255)')

True

>>> toColor('hsl(120,100%,50%)')==toColor('rgb(0,255,0)')

True

>>> toColor('rgba( 255,0,0,0.5)')==Color(1,0,0,0.5)

True

>>> toColor('cmyk(1,0,0,0 )')==CMYKColor(1,0,0,0)

True

>>> toColor('pcmyk( 100 , 0 , 0 , 0 )')==PCMYKColor(100,0,0,0)

True

>>> toColor('cmyka(1,0,0,0,0.5)')==CMYKColor(1,0,0,0,alpha=0.5)

True

>>> toColor('pcmyka(100,0,0,0,0.5)')==PCMYKColor(100,0,0,0,alpha=0.5)

True

>>> toColor('pcmyka(100,0,0,0)')

Traceback (most recent call last):

    ....

ValueError: css color 'pcmyka(100,0,0,0)' has wrong number of components

'''

import math, re

from reportlab.lib.utils import fp_str

import collections

class Color:

    """This class is used to represent color.  Components red, green, blue

    are in the range 0 (dark) to 1 (full intensity)."""

    def __init__(self, red=0, green=0, blue=0, alpha=1):

        "Initialize with red, green, blue in range [0-1]."

        self.red = red

        self.green = green

        self.blue = blue

        self.alpha = alpha

    def __repr__(self):

        return "Color(%s)" % fp_str(*(self.red, self.green, self.blue,self.alpha)).replace(' ',',')

    def __hash__(self):

        return hash((self.red, self.green, self.blue, self.alpha))

    def __cmp__(self,other):

        '''simple comparison by component; cmyk != color ever

        >>> cmp(Color(0,0,0),None)

        -1

        >>> cmp(Color(0,0,0),black)

        0

        >>> cmp(Color(0,0,0),CMYKColor(0,0,0,1)),Color(0,0,0).rgba()==CMYKColor(0,0,0,1).rgba()

        (-1, True)

        '''

        if isinstance(other,CMYKColor) or not isinstance(other,Color): return -1

        try:

            return cmp((self.red, self.green, self.blue, self.alpha),

                    (other.red, other.green, other.blue, other.alpha))

        except:

            return -1

        return 0

    def rgb(self):

        "Returns a three-tuple of components"

        return (self.red, self.green, self.blue)

    def rgba(self):

        "Returns a four-tuple of components"

        return (self.red, self.green, self.blue, self.alpha)

    def bitmap_rgb(self):

        return tuple([int(x*255)&255 for x in self.rgb()])

    def bitmap_rgba(self):

        return tuple([int(x*255)&255 for x in self.rgba()])

    def hexval(self):

        return '0x%02x%02x%02x' % self.bitmap_rgb()

    def hexvala(self):

        return '0x%02x%02x%02x%02x' % self.bitmap_rgba()

    def int_rgb(self):

        v = self.bitmap_rgb()

        return v[0]<<16|v[1]<<8|v[2]

    def int_rgba(self):

        v = self.bitmap_rgba()

        return int((v[0]<<24|v[1]<<16|v[2]<<8|v[3])&0xffffff)

    _cKwds='red green blue alpha'.split()

    def cKwds(self):

        for k in self._cKwds:

            yield k,getattr(self,k)

    cKwds=property(cKwds)

    def clone(self,**kwds):

        '''copy then change values in kwds'''

        D = dict([kv for kv in self.cKwds])

        D.update(kwds)

        return self.__class__(**D)

    def _lookupName(self,D={}):

        if not D:

            for n,v in getAllNamedColors().items():

                if not isinstance(v,CMYKColor):

                    t = v.red,v.green,v.blue

                    if t in D:

                        n = n+'/'+D[t]

                    D[t] = n

        t = self.red,self.green,self.blue

        return t in D and D[t] or None

    @property

    def normalizedAlpha(self):

        return self.alpha

class CMYKColor(Color):

    """This represents colors using the CMYK (cyan, magenta, yellow, black)

    model commonly used in professional printing.  This is implemented

    as a derived class so that renderers which only know about RGB "see it"

    as an RGB color through its 'red','green' and 'blue' attributes, according

    to an approximate function.

    The RGB approximation is worked out when the object in constructed, so

    the color attributes should not be changed afterwards.

    Extra attributes may be attached to the class to support specific ink models,

    and renderers may look for these."""

    _scale = 1.0

    def __init__(self, cyan=0, magenta=0, yellow=0, black=0,

                spotName=None, density=1, knockout=None, alpha=1):

        """

        Initialize with four colors in range [0-1]. the optional

        spotName, density & knockout may be of use to specific renderers.

        spotName is intended for use as an identifier to the renderer not client programs.

        density is used to modify the overall amount of ink.

        knockout is a renderer dependent option that determines whether the applied colour

        knocksout (removes) existing colour; None means use the global default.

        """

        self.cyan = cyan

        self.magenta = magenta

        self.yellow = yellow

        self.black = black

        self.spotName = spotName

        self.density = max(min(density,1),0)    # force into right range

        self.knockout = knockout

        self.alpha = alpha

        # now work out the RGB approximation. override

        self.red, self.green, self.blue = cmyk2rgb( (cyan, magenta, yellow, black) )

        if density<1:

            #density adjustment of rgb approximants, effectively mix with white

            r, g, b = self.red, self.green, self.blue

            r = density*(r-1)+1

            g = density*(g-1)+1

            b = density*(b-1)+1

            self.red, self.green, self.blue = (r,g,b)

    def __repr__(self):

        return "%s(%s%s%s%s%s)" % (self.__class__.__name__,

            fp_str(self.cyan, self.magenta, self.yellow, self.black).replace(' ',','),

            (self.spotName and (',spotName='+repr(self.spotName)) or ''),

            (self.density!=1 and (',density='+fp_str(self.density)) or ''),

            (self.knockout is not None and (',knockout=%d' % self.knockout) or ''),

            (self.alpha is not None and (',alpha=%s' % self.alpha) or ''),

            )

    def fader(self, n, reverse=False):

        '''return n colors based on density fade

        *NB* note this dosen't reach density zero'''

        scale = self._scale

        dd = scale/float(n)

        L = [self.clone(density=scale - i*dd) for i in range(n)]

        if reverse: L.reverse()

        return L

    def __hash__(self):

        return hash( (self.cyan, self.magenta, self.yellow, self.black, self.density, self.spotName, self.alpha) )

    def __cmp__(self,other):

        """obvious way to compare colours

        Comparing across the two color models is of limited use.

        >>> cmp(CMYKColor(0,0,0,1),None)

        -1

        >>> cmp(CMYKColor(0,0,0,1),_CMYK_black)

        0

        >>> cmp(PCMYKColor(0,0,0,100),_CMYK_black)

        0

        >>> cmp(CMYKColor(0,0,0,1),Color(0,0,1)),Color(0,0,0).rgba()==CMYKColor(0,0,0,1).rgba()

        (-1, True)

        """

        if not isinstance(other, CMYKColor): return -1

        try:

            return cmp(

                (self.cyan, self.magenta, self.yellow, self.black, self.density, self.alpha, self.spotName),

                (other.cyan, other.magenta, other.yellow, other.black, other.density, other.alpha, other.spotName))

        except: # or just return 'not equal' if not a color

            return -1

        return 0

    def cmyk(self):

        "Returns a tuple of four color components - syntactic sugar"

        return (self.cyan, self.magenta, self.yellow, self.black)

    def cmyka(self):

        "Returns a tuple of five color components - syntactic sugar"

        return (self.cyan, self.magenta, self.yellow, self.black, self.alpha)

    def _density_str(self):

        return fp_str(self.density)

    _cKwds='cyan magenta yellow black density alpha spotName knockout'.split()

    def _lookupName(self,D={}):

        if not D:

            for n,v in getAllNamedColors().items():

                if isinstance(v,CMYKColor):

                    t = v.cyan,v.magenta,v.yellow,v.black

                    if t in D:

                        n = n+'/'+D[t]

                    D[t] = n

        t = self.cyan,self.magenta,self.yellow,self.black

        return t in D and D[t] or None

    @property

    def normalizedAlpha(self):

        return self.alpha*self._scale

class PCMYKColor(CMYKColor):

    '''100 based CMYKColor with density and a spotName; just like Rimas uses'''

    _scale = 100.

    def __init__(self,cyan,magenta,yellow,black,density=100,spotName=None,knockout=None,alpha=100):

        CMYKColor.__init__(self,cyan/100.,magenta/100.,yellow/100.,black/100.,spotName,density/100.,knockout=knockout,alpha=alpha/100.)

    def __repr__(self):

        return "%s(%s%s%s%s%s)" % (self.__class__.__name__,

            fp_str(self.cyan*100, self.magenta*100, self.yellow*100, self.black*100).replace(' ',','),

            (self.spotName and (',spotName='+repr(self.spotName)) or ''),

            (self.density!=1 and (',density='+fp_str(self.density*100)) or ''),

            (self.knockout is not None and (',knockout=%d' % self.knockout) or ''),

            (self.alpha is not None and (',alpha=%s' % (fp_str(self.alpha*100))) or ''),

            )

    def cKwds(self):

        K=self._cKwds

        S=K[:6]

        for k in self._cKwds:

            v=getattr(self,k)

            if k in S: v*=100

            yield k,v

    cKwds=property(cKwds)

class CMYKColorSep(CMYKColor):

    '''special case color for making separating pdfs'''

    _scale = 1.

    def __init__(self, cyan=0, magenta=0, yellow=0, black=0,

                spotName=None, density=1,alpha=1):

        CMYKColor.__init__(self,cyan,magenta,yellow,black,spotName,density,knockout=None,alpha=alpha)

    _cKwds='cyan magenta yellow black density alpha spotName'.split()

class PCMYKColorSep(PCMYKColor,CMYKColorSep):

    '''special case color for making separating pdfs'''

    _scale = 100.

    def __init__(self, cyan=0, magenta=0, yellow=0, black=0,

                spotName=None, density=100, alpha=100):

        PCMYKColor.__init__(self,cyan,magenta,yellow,black,density,spotName,knockout=None,alpha=alpha)

    _cKwds='cyan magenta yellow black density alpha spotName'.split()

def cmyk2rgb(cmyk,density=1):

    "Convert from a CMYK color tuple to an RGB color tuple"

    c,m,y,k = cmyk

    # From the Adobe Postscript Ref. Manual 2nd ed.

    r = 1.0 - min(1.0, c + k)

    g = 1.0 - min(1.0, m + k)

    b = 1.0 - min(1.0, y + k)

    return (r,g,b)

def rgb2cmyk(r,g,b):

    '''one way to get cmyk from rgb'''

    c = 1 - r

    m = 1 - g

    y = 1 - b

    k = min(c,m,y)

    c = min(1,max(0,c-k))

    m = min(1,max(0,m-k))

    y = min(1,max(0,y-k))

    k = min(1,max(0,k))

    return (c,m,y,k)

def color2bw(colorRGB):

    "Transform an RGB color to a black and white equivalent."

    col = colorRGB

    r, g, b, a = col.red, col.green, col.blue, col.alpha

    n = (r + g + b) / 3.0

    bwColorRGB = Color(n, n, n, a)

    return bwColorRGB

def HexColor(val, htmlOnly=False, hasAlpha=False):

    """This function converts a hex string, or an actual integer number,

    into the corresponding color.  E.g., in "#AABBCC" or 0xAABBCC,

    AA is the red, BB is the green, and CC is the blue (00-FF).

    An alpha value can also be given in the form #AABBCCDD or 0xAABBCCDD where

    DD is the alpha value if hasAlpha is True.

    For completeness I assume that #aabbcc or 0xaabbcc are hex numbers

    otherwise a pure integer is converted as decimal rgb.  If htmlOnly is true,

    only the #aabbcc form is allowed.

    >>> HexColor('#ffffff')

    Color(1,1,1,1)

    >>> HexColor('#FFFFFF')

    Color(1,1,1,1)

    >>> HexColor('0xffffff')

    Color(1,1,1,1)

    >>> HexColor('16777215')

    Color(1,1,1,1)

    An '0x' or '#' prefix is required for hex (as opposed to decimal):

    >>> HexColor('ffffff')

    Traceback (most recent call last):

    ValueError: invalid literal for int() with base 10: 'ffffff'

    >>> HexColor('#FFFFFF', htmlOnly=True)

    Color(1,1,1,1)

    >>> HexColor('0xffffff', htmlOnly=True)

    Traceback (most recent call last):

    ValueError: not a hex string

    >>> HexColor('16777215', htmlOnly=True)

    Traceback (most recent call last):

    ValueError: not a hex string

    """ #" for emacs

    if isinstance(val,str):

        b = 10

        if val[:1] == '#':

            val = val[1:]

            b = 16

            if len(val) == 8:

                alpha = True

        else:

            if htmlOnly:

                raise ValueError('not a hex string')

            if val[:2].lower() == '0x':

                b = 16

                val = val[2:]

                if len(val) == 8:

                    alpha = True

        val = int(val,b)

    if hasAlpha:

        return Color(((val>>24)&0xFF)/255.0,((val>>16)&0xFF)/255.0,((val>>8)&0xFF)/255.0,(val&0xFF)/255.0)

    return Color(((val>>16)&0xFF)/255.0,((val>>8)&0xFF)/255.0,(val&0xFF)/255.0)

def linearlyInterpolatedColor(c0, c1, x0, x1, x):

    """

    Linearly interpolates colors. Can handle RGB, CMYK and PCMYK

    colors - give ValueError if colours aren't the same.

    Doesn't currently handle 'Spot Color Interpolation'.

    """

    if c0.__class__ != c1.__class__:

        raise ValueError("Color classes must be the same for interpolation!\nGot %r and %r'"%(c0,c1))

    if x1<x0:

        x0,x1,c0,c1 = x1,x0,c1,c0 # normalized so x1>x0

    if x<x0-1e-8 or x>x1+1e-8: # fudge factor for numerical problems

        raise ValueError("Can't interpolate: x=%f is not between %f and %f!" % (x,x0,x1))

    if x<=x0:

        return c0

    elif x>=x1:

        return c1

    cname = c0.__class__.__name__

    dx = float(x1-x0)

    x = x-x0

    if cname == 'Color': # RGB

        r = c0.red+x*(c1.red - c0.red)/dx

        g = c0.green+x*(c1.green- c0.green)/dx

        b = c0.blue+x*(c1.blue - c0.blue)/dx

        a = c0.alpha+x*(c1.alpha - c0.alpha)/dx

        return Color(r,g,b,alpha=a)

    elif cname == 'CMYKColor':

        if cmykDistance(c0,c1)<1e-8:

            #colors same do density and preserve spotName if any

            assert c0.spotName == c1.spotName, "Identical cmyk, but different spotName"

            c = c0.cyan

            m = c0.magenta

            y = c0.yellow

            k = c0.black

            d = c0.density+x*(c1.density - c0.density)/dx

            a = c0.alpha+x*(c1.alpha - c0.alpha)/dx

            return CMYKColor(c,m,y,k, density=d, spotName=c0.spotName, alpha=a)

        elif cmykDistance(c0,_CMYK_white)<1e-8:

            #special c0 is white

            c = c1.cyan

            m = c1.magenta

            y = c1.yellow

            k = c1.black

            d = x*c1.density/dx

            a = x*c1.alpha/dx

            return CMYKColor(c,m,y,k, density=d, spotName=c1.spotName, alpha=a)

        elif cmykDistance(c1,_CMYK_white)<1e-8:

            #special c1 is white

            c = c0.cyan

            m = c0.magenta

            y = c0.yellow

            k = c0.black

            d = x*c0.density/dx

            d = c0.density*(1-x/dx)

            a = c0.alpha*(1-x/dx)

            return PCMYKColor(c,m,y,k, density=d, spotName=c0.spotName, alpha=a)

        else:

            c = c0.cyan+x*(c1.cyan - c0.cyan)/dx

            m = c0.magenta+x*(c1.magenta - c0.magenta)/dx

            y = c0.yellow+x*(c1.yellow - c0.yellow)/dx

            k = c0.black+x*(c1.black - c0.black)/dx

            d = c0.density+x*(c1.density - c0.density)/dx

            a = c0.alpha+x*(c1.alpha - c0.alpha)/dx

            return CMYKColor(c,m,y,k, density=d, alpha=a)

    elif cname == 'PCMYKColor':

        if cmykDistance(c0,c1)<1e-8:

            #colors same do density and preserve spotName if any

            assert c0.spotName == c1.spotName, "Identical cmyk, but different spotName"

            c = c0.cyan

            m = c0.magenta

            y = c0.yellow

            k = c0.black

            d = c0.density+x*(c1.density - c0.density)/dx

            a = c0.alpha+x*(c1.alpha - c0.alpha)/dx

            return PCMYKColor(c*100,m*100,y*100,k*100, density=d*100,

                              spotName=c0.spotName, alpha=100*a)

        elif cmykDistance(c0,_CMYK_white)<1e-8:

            #special c0 is white

            c = c1.cyan

            m = c1.magenta

            y = c1.yellow

            k = c1.black

            d = x*c1.density/dx

            a = x*c1.alpha/dx

            return PCMYKColor(c*100,m*100,y*100,k*100, density=d*100,

                              spotName=c1.spotName, alpha=a*100)

        elif cmykDistance(c1,_CMYK_white)<1e-8:

            #special c1 is white

            c = c0.cyan

            m = c0.magenta

            y = c0.yellow

            k = c0.black

            d = x*c0.density/dx

            d = c0.density*(1-x/dx)

            a = c0.alpha*(1-x/dx)

            return PCMYKColor(c*100,m*100,y*100,k*100, density=d*100,

                              spotName=c0.spotName, alpha=a*100)

        else:

            c = c0.cyan+x*(c1.cyan - c0.cyan)/dx

            m = c0.magenta+x*(c1.magenta - c0.magenta)/dx

            y = c0.yellow+x*(c1.yellow - c0.yellow)/dx

            k = c0.black+x*(c1.black - c0.black)/dx

            d = c0.density+x*(c1.density - c0.density)/dx

            a = c0.alpha+x*(c1.alpha - c0.alpha)/dx

            return PCMYKColor(c*100,m*100,y*100,k*100, density=d*100, alpha=a*100)