def init_hol(hol, basecolor=None, pattern=None):
    """
    Initialize a Holiday to some random-ish colors
    """
    if basecolor is not None:
        (r, g, b) = webcolors.hex_to_rgb(basecolor)
        hol.fill(r, g, b)
    elif pattern is not None:
        for globeidx, vals in enumerate(pattern):
            (r, g, b) = webcolors.hex_to_rgb(vals)
            hol.setglobe(globeidx, r, g, b)
            pass
    else:
        for globeidx in range(0, HolidaySecretAPI.NUM_GLOBES):
            color = []
            # red
            color.append(random.randint(0, 130))
            #color.append(0)
            # green
            color.append(random.randint(0, 130))
            # blue
            color.append(random.randint(0, 130))
            #color.append(0)

            r, g, b = color

            hol.setglobe(globeidx, r, g, b)
            pass
    hol.render()

    pattern = hol.globes[:]
    return pattern

def colored_image(request, color):
    from webcolors import hex_to_rgb

    base_dir = join(settings.MEDIA_ROOT, 'event_logs')
    full_path = join(base_dir, '%s.png' % color)

    if hasattr(settings, 'USE_S3_STORAGE') and settings.USE_S3_STORAGE:
        rgb = hex_to_rgb('#%s' % color)
        image = Image.new('RGB', (1, 1), rgb)
        response = HttpResponse(mimetype="image/png")
        image.save(response, "PNG")
        return response
    else:
        # make the dir if it doesn't exist
        if not isdir(base_dir):
            mkdir(base_dir)

        try:
            f = open(full_path, 'rb')
            data = f.read()
            f.close()
        except:
            rgb = hex_to_rgb('#%s' % color)
            image = Image.new('RGB', (1, 1), rgb)
            image.save(full_path, "PNG")
            f = open(full_path, 'rb')
            data = f.read()
            f.close()

    return HttpResponse(data, mimetype="image/png")

    def closest_delta_e(self, hex):
        """
        Calculates the Delta E difference between a hex value and others in
        the specified palette and returns the closest match (CMC method)
        http://en.wikipedia.org/wiki/Color_difference#CMC_l:c_.281984.29
        """
        incumbent = RGBColor(*webcolors.hex_to_rgb(hex))

        shortest_dist = None
        nearest_colour = None
        for key, details in self.colours().items():

            candidate = RGBColor(*webcolors.hex_to_rgb(key))
            cdist = incumbent.delta_e(candidate, method="cmc")
            if nearest_colour is None:
                nearest_colour = (candidate, key, details)
                shortest_dist = cdist
            elif cdist < shortest_dist:
                shortest_dist = cdist
                nearest_colour = (candidate, key, details)

        details = nearest_colour[2]
        name = details['name']
        hex = self.hex(name)
        return hex, name

 def _parse_led_color(self, led, color):
     if led not in (LED_LOGO, LED_WHEEL):
         raise ValueError("Invalid LED: %s" % (led,))
     if is_strtype(color):
         try:
             color = webcolors.name_to_rgb(color)
         except ValueError:
             try:
                 color = webcolors.hex_to_rgb(color)
             except ValueError:
                 color = webcolors.hex_to_rgb("#" + color)
     if not hasattr(color, '__iter__'):
         raise ValueError("Invalid Color: %s" % (color, ))
     return color

def to_gray(hex_str):
    c = webcolors.hex_to_rgb(hex_str)
    g = int(c[0] * 0.299 + c[1] * 0.587 + c[2] * 0.114)
    c = (g, g, g)
    h = webcolors.rgb_to_hex(c)
    #return h if h != "#c7c7c7" else "#ffffff"
    return h

    def hex_me_up(self):

        self.hex_value = webcolors.rgb_to_hex(self.rgb)
        snapped, colour_name = swatchbook.closest_delta_e('css3', self.hex_value)
        snapped_rgb = webcolors.hex_to_rgb(snapped)
        hsv = self.rgb_to_hsv(*snapped_rgb)
        target = RGBColor(*snapped_rgb)
        original = RGBColor(*self.rgb)
        cdist = target.delta_e(original, method="cmc")
        prom = Decimal(self.prominence).quantize(TWOPLACES)
        dist = Decimal(cdist).quantize(TWOPLACES)
        ELITE = False

        self.css = {
            'r': self.rgb[0],
            'g': self.rgb[1],
            'b': self.rgb[2],
            'hue': hsv[0],
            'hex': snapped,
            'name': colour_name,
            'distance': float(dist),
            'prominence': float(prom),
            'elite': ELITE,
        }

        return self.css

def draw_event(draw, height, width, event, begintime):
	box = solve_box_corners(event, height, width)
	draw.rectangle(box, fill=webcolors.hex_to_rgb('#'+event.category.color))

	text = event.begin.time().strftime('%H:%M') + ' ' + event.category.name
	if event.split_tail is False:
		draw_text(draw, (box[0],box[1]+3), text)

def parsecolor(cc):
    if multiplier.search(cc):
        (fact, cc) = multiplier.split(cc, 1)
        fact = float(fact)
    else:
        fact = 1.

    cc = cc.strip()

    try:
        c = numpy.array(map(float, cc.split(',')))

        if c.size == 1: c = c.repeat(3)
        if c.size != 3: raise StandardError()

        return c * fact
    except ValueError: pass

    try:
        c = webcolors.hex_to_rgb(cc)
        return numpy.array(c)/255. * fact
    except ValueError: pass

    c = webcolors.name_to_rgb(cc)
    return numpy.array(c)/255. * fact

 def rgb(self, rgb):
     if type(rgb) is StringType and rgb[0] == '#':
         rgb = hex_to_rgb(rgb)
     elif type(rgb) is StringType:
         rgb = name_to_rgb(rgb)
     r,g,b = rgb
     return (b << 16) + (g << 8) + r

def text_color(css_color, light, dark):
    if css_color[0] == '#':
        color = webcolors.hex_to_rgb(css_color)
    else:
        color = webcolors.name_to_rgb(css_color)
    color = colorsys.rgb_to_hls(*(a / 255. for a in color))
    return light if color[1] < 0.7 else dark

def read(filename):
	colors = []
	basewidth = 100
	im = Image.open(filename)
	waspect = (basewidth/float(im.size[0]))
	haspect = int((float(im.size[1])*float(waspect)))
	im = im.resize((basewidth,haspect),PIL.Image.ANTIALIAS)
	if im.mode != "RGB":
		im = im.convert("RGB")
	px = im.load()
	width,height = im.size
	for i in range(0,height):
		for j in range(0,width):
			min_colors = {}
			r,g,b = px[j,i]
			for key,name in webcolors.css3_hex_to_names.items():
				rc,gc,bc = webcolors.hex_to_rgb(key)
				rd = (rc-r) ** 2
				gd = (gc-g) ** 2
				bd = (bc-b) ** 2
				min_colors[(rd+gd+bd)] = name
			color_name = min_colors[min(min_colors.keys())]
			if color_name not in colors:
				colors.append(color_name)
	return colors

def set_state():
    request_data = request.get_json().copy()
    color = request_data.pop('color', None)
    if color is not None:
        rgb = webcolors.hex_to_rgb(color)
        hls = colorsys.rgb_to_hls(*rgb)
        data['hue'] = hls[0]
        data['saturation'] = hls[2]
        data['brightness'] = hls[1]

    power = request_data.pop('power', None)
    if power is not None:
        if power in ['on', 'off']:
            data['power'] = power
            request_data['power'] = power
        else:
            return json.dumps({
                'error': "Invalid value for 'power'!"
            }, indent=4), 400

    for key, value in request_data.items():
        data['key'] = value

    return json.dumps({
        "results": [
            {
                "id": "l1fxl4mp",
                "label": "lamp",
                "status": "ok",
            }
        ]
    }, indent=4)

def resolve(deviceType, deviceAttr, values):
    """
    return one value to use for this attr, given a set of them that
    have come in simultaneously. len(values) >= 1.

    bug: some callers are passing a device instance for 1st arg
    """
    if len(values) == 1:
        return values[0]
    if deviceAttr == L9['color']:
        rgbs = [hex_to_rgb(v) for v in values]
        return rgb_to_hex([max(*component) for component in zip(*rgbs)])
    # incomplete. how-to-resolve should be on the DeviceAttr defs in the graph.
    if deviceAttr in [L9['rx'], L9['ry'], L9['zoom'], L9['focus'], L9['iris']]:
        floatVals = []
        for v in values:
            if isinstance(v, Literal):
                floatVals.append(float(v.toPython()))
            elif isinstance(v, (int, float)):
                floatVals.append(float(v))
            else:
                raise TypeError(repr(v))

        # averaging with zeros? not so good
        return Literal(sum(floatVals) / len(floatVals))
    return max(values)

def make_rainbow(colours, width, height):

    count = len(colours)
    slice = 100

    width = slice * count
    height = 200

    im = Image.new("RGBA", (width, height))
    canvas = ImageDraw.Draw(im)

    dx = width / float(len(colours)) 
    x = 0
    y = height / 2.0

    for hex in colours:

        rgb = webcolors.hex_to_rgb(hex)

        canvas.line((x, y, x + dx, y), width=height, fill=rgb)
        canvas.text((x + 10, 10), hex, fill=(255,255,255))

        x += dx

    return im

def readable_text_color(color_hex):
    r, g, b = webcolors.hex_to_rgb(color_hex)
    # Calculate brightness of the background and compare to threshold
    if 0.2126 * r + 0.7152 * g+ 0.0722 * b < 0.279*255:
        return "#FFFFFF"
    else:
        return "#000000"

def __parseColor(color):
    try:
        return webcolors.name_to_rgb(color)
    except ValueError:
        if not color.startswith('#'):
            color = "#" + color
        return webcolors.hex_to_rgb(color)

def set_led_color(led, color):
    if led not in (LED_LOGO, LED_WHEEL):
        raise ValueError("Invalid LED: %s" % (led,))
    if is_strtype(color):
        try:
            color = webcolors.name_to_rgb(color)
        except ValueError:
            try:
                color = webcolors.hex_to_rgb(color)
            except ValueError:
                color = webcolors.hex_to_rgb("#" + color)

    if not hasattr(color, '__iter__'):
        raise ValueError("Invalid Color: %s" % (color, ))

    args = (chr(led),) + tuple([chr(b) for b in color])
    return "\x08%s%s%s%s" % args

def color2intensity(colorString, minIntensity=0, maxIntensity=1000):
	if colorString == "" or colorString == "none": 
		return minIntensity
	else:
		rgb = webcolors.hex_to_rgb(colorString)
		gray = 0.2989 * rgb[0] + 0.5870 * rgb[1] + 0.1140 * rgb[2]
		intensity = (1-gray/255) * (maxIntensity-minIntensity) + minIntensity
		return intensity

	def get_colour_name(self, rgb_triplet):
	    min_colours = {}
	    for key, name in webcolors.css21_hex_to_names.items():
	        r_c, g_c, b_c = webcolors.hex_to_rgb(key)
	        rd = (r_c - rgb_triplet[0]) ** 2
	        gd = (g_c - rgb_triplet[1]) ** 2
	        bd = (b_c - rgb_triplet[2]) ** 2
	        min_colours[(rd + gd + bd)] = name
	    return min_colours[min(min_colours.keys())]

 def hex_to_wdcolor(value):
     """
     Receive a HEX color attribute string like '#9bbb59' (or '9bbb59') and transform it to a numeric constant
     in order to use it as a Selection.Font.Color attribute (as an item of WdColor enumeration)
     :param value: A HEX color attribute
     :return: A numeric WDCOLOR value
     """
     rgbstrlst = webcolors.hex_to_rgb(value)
     return int(rgbstrlst[0]) + 0x100 * int(rgbstrlst[1]) + 0x10000 * int(rgbstrlst[2])