Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 1 | """Color Database. |
| 2 | |
Barry Warsaw | a9053f6 | 1998-10-02 16:01:42 +0000 | [diff] [blame] | 3 | This file contains one class, called ColorDB, and several utility functions. |
| 4 | The class must be instantiated by the get_colordb() function in this file, |
| 5 | passing it a filename to read a database out of. |
| 6 | |
| 7 | The get_colordb() function will try to examine the file to figure out what the |
| 8 | format of the file is. If it can't figure out the file format, or it has |
| 9 | trouble reading the file, None is returned. You can pass get_colordb() an |
| 10 | optional filetype argument. |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 11 | |
| 12 | Supporte file types are: |
| 13 | |
| 14 | X_RGB_TXT -- X Consortium rgb.txt format files. Three columns of numbers |
| 15 | from 0 .. 255 separated by whitespace. Arbitrary trailing |
| 16 | columns used as the color name. |
Barry Warsaw | a9053f6 | 1998-10-02 16:01:42 +0000 | [diff] [blame] | 17 | |
| 18 | The utility functions are useful for converting between the various expected |
| 19 | color formats, and for calculating other color values. |
| 20 | |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 21 | """ |
| 22 | |
| 23 | import sys |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 24 | import string |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 25 | import re |
Barry Warsaw | f4562a7 | 1998-02-11 17:19:23 +0000 | [diff] [blame] | 26 | from types import * |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 27 | import operator |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 28 | |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 29 | class BadColor(Exception): |
| 30 | pass |
| 31 | |
Barry Warsaw | f4562a7 | 1998-02-11 17:19:23 +0000 | [diff] [blame] | 32 | DEFAULT_DB = None |
| 33 | |
Barry Warsaw | a5a018f | 1998-09-25 22:51:36 +0000 | [diff] [blame] | 34 | |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 35 | |
| 36 | # generic class |
| 37 | class ColorDB: |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 38 | def __init__(self, fp): |
| 39 | lineno = 2 |
| 40 | self.__name = fp.name |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 41 | # Maintain several dictionaries for indexing into the color database. |
| 42 | # Note that while Tk supports RGB intensities of 4, 8, 12, or 16 bits, |
| 43 | # for now we only support 8 bit intensities. At least on OpenWindows, |
| 44 | # all intensities in the /usr/openwin/lib/rgb.txt file are 8-bit |
| 45 | # |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 46 | # key is (red, green, blue) tuple, value is (name, [aliases]) |
| 47 | self.__byrgb = {} |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 48 | # |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 49 | # key is name, value is (red, green, blue) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 50 | self.__byname = {} |
| 51 | # |
Barry Warsaw | 8be2594 | 1998-10-02 14:43:30 +0000 | [diff] [blame] | 52 | # all unique names (non-aliases). built-on demand |
| 53 | self.__allnames = None |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 54 | while 1: |
| 55 | line = fp.readline() |
| 56 | if not line: |
| 57 | break |
| 58 | # get this compiled regular expression from derived class |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 59 | ## print '%3d: %s' % (lineno, line[:-1]) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 60 | mo = self._re.match(line) |
| 61 | if not mo: |
| 62 | sys.stderr.write('Error in %s, line %d\n' % (fp.name, lineno)) |
| 63 | lineno = lineno + 1 |
| 64 | continue |
| 65 | # |
| 66 | # extract the red, green, blue, and name |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 67 | # |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 68 | red, green, blue = self._extractrgb(mo) |
| 69 | name = self._extractname(mo) |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 70 | keyname = string.lower(name) |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 71 | ## print keyname, '(%d, %d, %d)' % (red, green, blue) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 72 | # |
| 73 | # TBD: for now the `name' is just the first named color with the |
| 74 | # rgb values we find. Later, we might want to make the two word |
| 75 | # version the `name', or the CapitalizedVersion, etc. |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 76 | # |
| 77 | key = (red, green, blue) |
| 78 | foundname, aliases = self.__byrgb.get(key, (name, [])) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 79 | if foundname <> name and foundname not in aliases: |
| 80 | aliases.append(name) |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 81 | self.__byrgb[key] = (foundname, aliases) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 82 | # |
| 83 | # add to byname lookup |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 84 | # |
| 85 | self.__byname[keyname] = key |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 86 | lineno = lineno + 1 |
| 87 | |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 88 | # override in derived classes |
| 89 | def _extractrgb(self, mo): |
| 90 | return map(int, mo.group('red', 'green', 'blue')) |
| 91 | |
| 92 | def _extractname(self, mo): |
| 93 | return mo.group('name') |
| 94 | |
| 95 | def filename(self): |
| 96 | return self.__name |
| 97 | |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 98 | def find_byrgb(self, rgbtuple): |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 99 | """Return name for rgbtuple""" |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 100 | try: |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 101 | return self.__byrgb[rgbtuple] |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 102 | except KeyError: |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 103 | raise BadColor(rgbtuple) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 104 | |
| 105 | def find_byname(self, name): |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 106 | """Return (red, green, blue) for name""" |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 107 | name = string.lower(name) |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 108 | try: |
| 109 | return self.__byname[name] |
| 110 | except KeyError: |
| 111 | raise BadColor(name) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 112 | |
Barry Warsaw | 7a13418 | 1998-09-29 20:03:15 +0000 | [diff] [blame] | 113 | def nearest(self, red, green, blue): |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 114 | """Return the name of color nearest (red, green, blue)""" |
| 115 | # TBD: should we use Voronoi diagrams, Delaunay triangulation, or |
| 116 | # octree for speeding up the locating of nearest point? Exhaustive |
| 117 | # search is inefficient, but seems fast enough. |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 118 | nearest = -1 |
| 119 | nearest_name = '' |
Barry Warsaw | eb9b8af | 1998-02-11 18:55:37 +0000 | [diff] [blame] | 120 | for name, aliases in self.__byrgb.values(): |
| 121 | r, g, b = self.__byname[string.lower(name)] |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 122 | rdelta = red - r |
| 123 | gdelta = green - g |
| 124 | bdelta = blue - b |
| 125 | distance = rdelta * rdelta + gdelta * gdelta + bdelta * bdelta |
| 126 | if nearest == -1 or distance < nearest: |
| 127 | nearest = distance |
| 128 | nearest_name = name |
| 129 | return nearest_name |
Barry Warsaw | 8be2594 | 1998-10-02 14:43:30 +0000 | [diff] [blame] | 130 | |
Barry Warsaw | 9f3ea21 | 1998-10-02 15:59:20 +0000 | [diff] [blame] | 131 | def unique_names(self): |
Barry Warsaw | 8be2594 | 1998-10-02 14:43:30 +0000 | [diff] [blame] | 132 | # sorted |
| 133 | if not self.__allnames: |
| 134 | self.__allnames = [] |
| 135 | for name, aliases in self.__byrgb.values(): |
| 136 | self.__allnames.append(name) |
Barry Warsaw | 9f3ea21 | 1998-10-02 15:59:20 +0000 | [diff] [blame] | 137 | # sort irregardless of case |
| 138 | def nocase_cmp(n1, n2): |
| 139 | return cmp(string.lower(n1), string.lower(n2)) |
| 140 | self.__allnames.sort(nocase_cmp) |
Barry Warsaw | 8be2594 | 1998-10-02 14:43:30 +0000 | [diff] [blame] | 141 | return self.__allnames |
Barry Warsaw | 9f3ea21 | 1998-10-02 15:59:20 +0000 | [diff] [blame] | 142 | |
| 143 | def aliases_of(self, red, green, blue): |
| 144 | try: |
| 145 | name, aliases = self.__byrgb[(red, green, blue)] |
| 146 | except KeyError: |
| 147 | raise BadColor((red, green, blue)) |
| 148 | return [name] + aliases |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 149 | |
| 150 | |
| 151 | class RGBColorDB(ColorDB): |
| 152 | _re = re.compile( |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 153 | '\s*(?P<red>\d+)\s+(?P<green>\d+)\s+(?P<blue>\d+)\s+(?P<name>.*)') |
| 154 | |
| 155 | |
| 156 | class HTML40DB(ColorDB): |
| 157 | _re = re.compile('(?P<name>\S+)\s+(?P<hexrgb>#[0-9a-fA-F]{6})') |
| 158 | |
| 159 | def _extractrgb(self, mo): |
| 160 | return rrggbb_to_triplet(mo.group('hexrgb')) |
| 161 | |
| 162 | class LightlinkDB(HTML40DB): |
| 163 | _re = re.compile('(?P<name>(.+))\s+(?P<hexrgb>#[0-9a-fA-F]{6})') |
| 164 | |
| 165 | def _extractname(self, mo): |
| 166 | return string.strip(mo.group('name')) |
| 167 | |
| 168 | class WebsafeDB(ColorDB): |
| 169 | _re = re.compile('(?P<hexrgb>#[0-9a-fA-F]{6})') |
| 170 | |
| 171 | def _extractrgb(self, mo): |
| 172 | return rrggbb_to_triplet(mo.group('hexrgb')) |
| 173 | |
| 174 | def _extractname(self, mo): |
| 175 | return string.upper(mo.group('hexrgb')) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 176 | |
| 177 | |
| 178 | |
| 179 | # format is a tuple (RE, SCANLINES, CLASS) where RE is a compiled regular |
| 180 | # expression, SCANLINES is the number of header lines to scan, and CLASS is |
| 181 | # the class to instantiate if a match is found |
| 182 | |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 183 | FILETYPES = [ |
| 184 | (re.compile('XConsortium'), RGBColorDB), |
| 185 | (re.compile('HTML'), HTML40DB), |
| 186 | (re.compile('lightlink'), LightlinkDB), |
| 187 | (re.compile('Websafe'), WebsafeDB), |
| 188 | ] |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 189 | |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 190 | def get_colordb(file, filetype=None): |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 191 | colordb = None |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 192 | fp = open(file) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 193 | try: |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 194 | line = fp.readline() |
| 195 | if not line: |
| 196 | return None |
| 197 | # try to determine the type of RGB file it is |
| 198 | if filetype is None: |
| 199 | filetypes = FILETYPES |
| 200 | else: |
| 201 | filetypes = [filetype] |
| 202 | for typere, class_ in filetypes: |
| 203 | mo = typere.search(line) |
| 204 | if mo: |
| 205 | break |
| 206 | else: |
| 207 | # no matching type |
| 208 | return None |
| 209 | # we know the type and the class to grok the type, so suck it in |
| 210 | colordb = class_(fp) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 211 | finally: |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 212 | fp.close() |
Barry Warsaw | f4562a7 | 1998-02-11 17:19:23 +0000 | [diff] [blame] | 213 | # save a global copy |
| 214 | global DEFAULT_DB |
| 215 | DEFAULT_DB = colordb |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 216 | return colordb |
| 217 | |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 218 | |
| 219 | |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 220 | _namedict = {} |
Barry Warsaw | 2e7a320 | 1998-02-18 17:01:12 +0000 | [diff] [blame] | 221 | def rrggbb_to_triplet(color, atoi=string.atoi): |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 222 | """Converts a #rrggbb color to the tuple (red, green, blue).""" |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 223 | global _namedict |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 224 | rgbtuple = _namedict.get(color) |
| 225 | if rgbtuple is None: |
Barry Warsaw | b7b1cf0 | 1998-10-06 18:10:59 +0000 | [diff] [blame] | 226 | if color[0] <> '#': |
| 227 | raise BadColor(color) |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 228 | red = color[1:3] |
| 229 | green = color[3:5] |
| 230 | blue = color[5:7] |
Barry Warsaw | 2e7a320 | 1998-02-18 17:01:12 +0000 | [diff] [blame] | 231 | rgbtuple = (atoi(red, 16), atoi(green, 16), atoi(blue, 16)) |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 232 | _namedict[color] = rgbtuple |
| 233 | return rgbtuple |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 234 | |
Barry Warsaw | f4562a7 | 1998-02-11 17:19:23 +0000 | [diff] [blame] | 235 | |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 236 | _tripdict = {} |
Barry Warsaw | f4562a7 | 1998-02-11 17:19:23 +0000 | [diff] [blame] | 237 | def triplet_to_rrggbb(rgbtuple): |
| 238 | """Converts a (red, green, blue) tuple to #rrggbb.""" |
Barry Warsaw | 0604d72 | 1999-04-26 23:17:16 +0000 | [diff] [blame] | 239 | global _tripdict |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 240 | hexname = _tripdict.get(rgbtuple) |
| 241 | if hexname is None: |
Barry Warsaw | 2e7a320 | 1998-02-18 17:01:12 +0000 | [diff] [blame] | 242 | hexname = '#%02x%02x%02x' % rgbtuple |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 243 | _tripdict[rgbtuple] = hexname |
| 244 | return hexname |
Barry Warsaw | 9f4d73a | 1998-01-31 23:38:48 +0000 | [diff] [blame] | 245 | |
| 246 | |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 247 | _maxtuple = (256.0,) * 3 |
Barry Warsaw | a5a018f | 1998-09-25 22:51:36 +0000 | [diff] [blame] | 248 | def triplet_to_fractional_rgb(rgbtuple): |
Barry Warsaw | 8d3e5ee | 1998-02-18 00:02:26 +0000 | [diff] [blame] | 249 | return map(operator.__div__, rgbtuple, _maxtuple) |
Barry Warsaw | 2662e15 | 1998-02-13 21:27:56 +0000 | [diff] [blame] | 250 | |
| 251 | |
Barry Warsaw | 0e3e699 | 1998-09-28 23:39:18 +0000 | [diff] [blame] | 252 | def triplet_to_brightness(rgbtuple): |
| 253 | # return the brightness (grey level) along the scale 0.0==black to |
| 254 | # 1.0==white |
| 255 | r = 0.299 |
| 256 | g = 0.587 |
| 257 | b = 0.114 |
| 258 | return r*rgbtuple[0] + g*rgbtuple[1] + b*rgbtuple[2] |
| 259 | |
| 260 | |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 261 | |
| 262 | if __name__ == '__main__': |
| 263 | import string |
| 264 | |
| 265 | colordb = get_colordb('/usr/openwin/lib/rgb.txt') |
| 266 | if not colordb: |
| 267 | print 'No parseable color database found' |
| 268 | sys.exit(1) |
| 269 | # on my system, this color matches exactly |
| 270 | target = 'navy' |
Barry Warsaw | a5a018f | 1998-09-25 22:51:36 +0000 | [diff] [blame] | 271 | red, green, blue = rgbtuple = colordb.find_byname(target) |
| 272 | print target, ':', red, green, blue, triplet_to_rrggbb(rgbtuple) |
| 273 | name, aliases = colordb.find_byrgb(rgbtuple) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 274 | print 'name:', name, 'aliases:', string.join(aliases, ", ") |
Barry Warsaw | 840a84d | 1998-10-15 02:18:08 +0000 | [diff] [blame] | 275 | r, g, b = (1, 1, 128) # nearest to navy |
| 276 | r, g, b = (145, 238, 144) # nearest to lightgreen |
| 277 | r, g, b = (255, 251, 250) # snow |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 278 | print 'finding nearest to', target, '...' |
| 279 | import time |
| 280 | t0 = time.time() |
Barry Warsaw | 840a84d | 1998-10-15 02:18:08 +0000 | [diff] [blame] | 281 | nearest = colordb.nearest(r, g, b) |
Barry Warsaw | 2406b1d | 1998-01-31 00:29:41 +0000 | [diff] [blame] | 282 | t1 = time.time() |
| 283 | print 'found nearest color', nearest, 'in', t1-t0, 'seconds' |
Barry Warsaw | 840a84d | 1998-10-15 02:18:08 +0000 | [diff] [blame] | 284 | # dump the database |
| 285 | for n in colordb.unique_names(): |
| 286 | r, g, b = colordb.find_byname(n) |
| 287 | aliases = colordb.aliases_of(r, g, b) |
| 288 | print '%20s: (%3d/%3d/%3d) == %s' % (n, r, g, b, |
| 289 | string.join(aliases[1:])) |