def _loadconfig(self):
     logger.info("Loading configuration from config.txt")
     config = None
     if os.path.isfile("config.txt"):
         try:
             config = load(open("config.txt",'r'))
             required_settings = ['hue_bridge_ip','twitch_username','twitch_oauth','twitch_channel','color_1','color_2','times_to_flash','flash_speed']
             for setting in required_settings:
                 if not setting in config:
                     logger.critical('%s is not present in config.txt, please put it there! check config_example.txt!' %setting)
                     sys.exit()
                 #don't allow unicode!
                 if isinstance(config[setting],unicode):
                     config[setting] = str(remove_nonascii(config[setting]))
             try:
                 config['color_1'] = webcolors.name_to_rgb(config['color_1'])
                 config['color_2'] = webcolors.name_to_rgb(config['color_2'])
             except Exception, e:
                 logger.critical("Problem interpreting your color choices, please consult http://www.cssportal.com/css3-color-names/ for valid color names")
                 logger.debug(e.message)
                 sys.exit()
         except SystemExit:
             sys.exit()
         except Exception, e:
             logger.info(e)
             logger.critical("Problem loading configuration file, try deleting config.txt and starting again")

 def handle_action(self, device, cfg):
     for key , value in cfg['action'].iteritems():
         if key == 'flash':
             c1 = webcolors.name_to_rgb(value['color_1'])
             c2 = webcolors.name_to_rgb(value['color_2'])
             count = value['times_to_flash']
             speed = value['flash_speed']
             device.flash(c1, c2, count, speed)
         elif key == 'set_color':
             c1 = webcolors.name_to_rgb(value['color'])
             device.set_color(c1)
         elif key == 'turn_on':
             device.turn_on()
         elif key == 'turn_off':
             device.turn_off()
         elif key == 'turn_on_timer':
             duration = value['duration']
             device.turn_on_timer(duration)
         elif key == 'turn_off_timer':
             duration = value['duration']
             device.turn_off_timer(duration)
         elif key == 'light_wave':
             c1 = webcolors.name_to_rgb(value['color_1'])
             c2 = webcolors.name_to_rgb(value['color_2'])
             duration = value['duration']
             device.light_wave(c1, c2, duration)
         elif key == 'lightning':
             device.lightning(1500)
         elif key == 'play_sound':
             sound_fn = value['sound_wav']
             winsound.PlaySound(sound_fn, winsound.SND_FILENAME | winsound.SND_ASYNC)

 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 _format_color(color, prog='tikz'):
    """Encode color in syntax for given program.

    @type color:
      - C{str} for single color or
      - C{dict} for weighted color mix

    @type prog: 'tikz' or 'dot'
    """
    if isinstance(color, basestring):
        return color

    if not isinstance(color, dict):
        raise Exception('color must be str or dict')

    if prog is 'tikz':
        s = '!'.join([k + '!' + str(v) for k, v in color.iteritems()])
    elif prog is 'dot':
        t = sum(color.itervalues())

        try:
            import webcolors

            # mix them
            result = np.array((0.0, 0.0, 0.0))
            for c, w in color.iteritems():
                result += w/t * np.array(webcolors.name_to_rgb(c))
            s = webcolors.rgb_to_hex(result)
        except:
            logger.warn('failed to import webcolors')
            s = ':'.join([k + ';' + str(v/t) for k, v in color.iteritems()])
    else:
        raise ValueError('Unknown program: ' + str(prog) + '. '
                         "Available options are: 'dot' or 'tikz'.")
    return s

def frame_edges_of_all_images(wide, color, directory=None):
    
    if directory == None:
        directory = os.getcwd() # Use working directory if unspecified
        
    # Create a new directory 'Framed'
    new_directory = os.path.join(directory, 'Framed')
    try:
        os.mkdir(new_directory)
    except OSError:
        pass # if the directory already exists, proceed  
    
    #load all the images
    image_list, file_list = get_images(directory)  
    color = webcolors.name_to_rgb(color)
    #go through the images and save modified versions
    for n in range(len(image_list)):
        # Parse the filename
        filename, filetype = file_list[n].split('.')
        
        
        new_image = frame_edges(image_list[n],wide,color)
        #save the altered image, suing PNG to retain transparency
        new_image_filename = os.path.join(new_directory, filename + '.png')
        new_image.save(new_image_filename)  

 def test_parse_legacy_color_names(self):
     """
     Test the HTML5 legacy color parsing of SVG/CSS3 color names.
     """
     for name in webcolors.CSS3_NAMES_TO_HEX.keys():
         self.assertEqual(webcolors.name_to_rgb(name),
                          webcolors.html5_parse_legacy_color(name))

def autocrop_image(inputfilename, outputfilename = None, color = 'white', newWidth = None,
                   doShow = False ):
    im = Image.open(inputfilename)
    try:
        # get hex colors
        rgbcolor = hex_to_rgb( color )
    except Exception:
        if color not in _all_possible_colornames:
            raise ValueError("Error, color name = %s not in valid set of color names.")
        rgbcolor = webcolors.name_to_rgb(color)
    bg = Image.new(im.mode, im.size, rgbcolor)
    diff = ImageChops.difference(im, bg)
    diff = ImageChops.add(diff, diff, 2.0, -100)
    bbox = diff.getbbox()
    if bbox:
        cropped = im.crop(bbox)
        if newWidth is not None:
            height = int( newWidth * 1.0 / cropped.size[0] * cropped.size[1] )
            cropped = cropped.resize(( newWidth, height ))
        if outputfilename is None:
            cropped.save(inputfilename)
        else:
            cropped.save(os.path.expanduser(outputfilename))
        if doShow:
            cropped.show( )
        return True
    else:
        return False

    def name_to_color(name, opacity=0):
        try:
            r, g, b = webcolors.name_to_rgb(name)
        except ValueError:
            r, g, b = 0, 0, 0

        return Colors._format_color(r, g, b, opacity)

def strobe(color="white"):

	if color != "white":
		rgb = re.sub('[() ]', '', str(webcolors.name_to_rgb(color)))
	else:
		rgb = "255,255,255"
	call(["python", "%s/FluxScripts/flux_led.py" % os.getcwd(), "10.0.1.4", "-C", "strobe", "100", rgb])

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 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 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 make_ica_maps(data, imgs, img_size_x, img_size_y, num_ica_colors, color_map, colors_ica):
    
    reference = data.seriesMean().pack()
    maps = Colorize(cmap=color_map, colors = colors_ica[0:np.size(imgs,0)], scale=num_ica_colors).transform(abs(imgs),background=reference, mixing=1.5)
        
    #Count number of unique colors in the images
    #Get number of planes based on map dimesnions
    if len(maps.shape)==3:
        num_planes = 1
    else:
        num_planes = np.size(maps,2)
        
    unique_clrs = []
    for ii in xrange(0, np.size(colors_ica[0:np.size(imgs,0)])):
        unique_clrs.append( np.round(np.array(webcolors.name_to_rgb(colors_ica[ii]), dtype=np.float)/255))
    
    #From maps get number of pixel matches with color for each plane
    matched_pixels = np.zeros((np.size(unique_clrs,0),num_planes))
    array_maps = np.round(maps.astype(np.float16))
    matched_pixels = np.zeros((np.size(unique_clrs,0),num_planes))
    if len(maps.shape) == 3:
        array_maps_plane = np.reshape(array_maps, (np.size(array_maps,0)*np.size(array_maps,1),3))
        matched_pixels[:,0] = [np.size(np.where((np.array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs]
    else:     
        for ii in xrange(0,num_planes):
            array_maps_plane = np.reshape(array_maps[:,:,ii,:], (np.size(array_maps,0)*np.size(array_maps,1),3))
            matched_pixels[:,ii] = [np.size(np.where((np.array(array_maps_plane) == match).all(axis=1))) for match in unique_clrs]
                 
    
    return maps, matched_pixels

    def draw(self):
        pygame.init()
        
        screen_edge = 400
        
        cell_count = self.grid * self.grid
        
        cell_edge = screen_edge / self.grid
        
        screen = pygame.display.set_mode((screen_edge+100, screen_edge))
        myfont = pygame.font.SysFont("calibri", 30)
    
        for row in range(0, len(self.board)):
            for col in range(0, len(self.board[row])):
                #color_input = input("Enter color: ")
                rndm_clr = (255, 255, 255)
                value = str(self.board[row][col]) if self.board[row][col] is not None else "*"
                
                x = col*cell_edge
                y = row*cell_edge
                               
                pygame.draw.rect(screen,rndm_clr,(x, y,cell_edge,cell_edge), 3)          
        
            # render text
                
                if self.board[row][col] is not None:
                    value = str(self.board[row][col])
                    label = myfont.render(value, 1, webcolors.name_to_rgb("white"))
                else:
                    value = "*"
                    label = myfont.render(value, 1, webcolors.name_to_rgb("red"))
                
                
                #draw number on rectangle
                screen.blit(label, (x+(cell_edge/self.grid),y+(cell_edge/self.grid)))

               # pygame.time.wait(40)
        
        small_font = pygame.font.SysFont("calibri", 18)
        label = small_font.render("Chances: " + str(self.chance), 1, webcolors.name_to_rgb("white"))
        screen.blit(label, (screen_edge + 5, 0))
        
        pygame.event.pump()
        pygame.display.flip()

        if self.state ==  "w":
            pygame.display.quit()

 def get_usercolor(self, username, usercolor=None):
     if usercolor:
         usercolor = usercolor[1:]  # cut off the # from the start of the string
         hexcolor = (int(usercolor[:2], 16), int(usercolor[2:4], 16), int(usercolor[4:], 16))
         return hexcolor
     elif username not in self.usercolors:
         self.usercolors[username] = webcolors.name_to_rgb(random.choice(TWITCH_COLORS))
     return self.usercolors[username]

    def test_svg_definition_conformance(self):
        """
        Compare the results of name-to-rgb-triplet conversion to the
        canonical triplet values provided in the SVG specification.

        """
        for color, triplet in SVG_COLOR_DEFINITIONS.items():
            assert triplet == webcolors.name_to_rgb(color)

def parse_eastereggs(cmd, state):
    if _match(cmd, 'let there be light'):
        state.power = True
    if _match(cmd, 'sleep'):
        state.power = False
    if _match(cmd, 'go to hell'):
        state.color = webcolors.name_to_rgb('red')
    return (cmd, state)

 def fade_to_color(self, fade_milliseconds, color):
     """
     Fade the light to a known colour in a
     :param fade_milliseconds: Duration of the fade in milliseconds
     :param color: Named color to fade to
     :return: None
     """
     red, green, blue = webcolors.name_to_rgb(color)
     return self.fade_to_rgb(fade_milliseconds, red, green, blue)

def parse_color(cmd, state):
    for word in cmd:
        try:
            state.color = webcolors.name_to_rgb(word)
            cmd.remove(word)
            break
        except ValueError:
            continue
    return (cmd, state)

def color_to_rgb(color):
    import webcolors
    if color == 'none' or isinstance(color, (list, tuple)):
        rgb = color
    elif re.match('#', color):
        rgb = webcolors.hex_to_rgb(color)
    else:
        rgb = webcolors.name_to_rgb(color)

    return rgb