home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Inkscape / Inkscape-0.48.2-1-win32.exe / python / Lib / site-packages / PIL / ImagePalette.py < prev    next >
Encoding:
Python Source  |  2010-03-06  |  4.8 KB  |  162 lines
  1. #
  2. # The Python Imaging Library.
  3. # $Id: ImagePalette.py 2339 2005-03-25 08:02:17Z fredrik $
  4. #
  5. # image palette object
  6. #
  7. # History:
  8. # 1996-03-11 fl   Rewritten.
  9. # 1997-01-03 fl   Up and running.
  10. # 1997-08-23 fl   Added load hack
  11. # 2001-04-16 fl   Fixed randint shadow bug in random()
  12. #
  13. # Copyright (c) 1997-2001 by Secret Labs AB
  14. # Copyright (c) 1996-1997 by Fredrik Lundh
  15. #
  16. # See the README file for information on usage and redistribution.
  17. #
  18.  
  19. import array
  20. import Image
  21.  
  22. ##
  23. # Colour palette wrapper for palette mapped images.
  24.  
  25. class ImagePalette:
  26.     "Colour palette for palette mapped images"
  27.  
  28.     def __init__(self, mode = "RGB", palette = None):
  29.         self.mode = mode
  30.         self.rawmode = None # if set, palette contains raw data
  31.         self.palette = palette or range(256)*len(self.mode)
  32.         self.colors = {}
  33.         self.dirty = None
  34.         if len(self.mode)*256 != len(self.palette):
  35.             raise ValueError, "wrong palette size"
  36.  
  37.     def getdata(self):
  38.         # experimental: get palette contains in format suitable
  39.         # for the low-level im.putpalette primitive
  40.         if self.rawmode:
  41.             return self.rawmode, self.palette
  42.         return self.mode + ";L", self.tostring()
  43.  
  44.     def tostring(self):
  45.         # experimental: convert palette to string
  46.         if self.rawmode:
  47.             raise ValueError("palette contains raw palette data")
  48.         if Image.isStringType(self.palette):
  49.             return self.palette
  50.         return array.array("B", self.palette).tostring()
  51.  
  52.     def getcolor(self, color):
  53.         # experimental: given an rgb tuple, allocate palette entry
  54.         if self.rawmode:
  55.             raise ValueError("palette contains raw palette data")
  56.         if Image.isTupleType(color):
  57.             try:
  58.                 return self.colors[color]
  59.             except KeyError:
  60.                 # allocate new color slot
  61.                 if Image.isStringType(self.palette):
  62.                     self.palette = map(int, self.palette)
  63.                 index = len(self.colors)
  64.                 if index >= 256:
  65.                     raise ValueError("cannot allocate more than 256 colors")
  66.                 self.colors[color] = index
  67.                 self.palette[index] = color[0]
  68.                 self.palette[index+256] = color[1]
  69.                 self.palette[index+512] = color[2]
  70.                 self.dirty = 1
  71.                 return index
  72.         else:
  73.             raise ValueError("unknown color specifier: %r" % color)
  74.  
  75.     def save(self, fp):
  76.         # (experimental) save palette to text file
  77.         if self.rawmode:
  78.             raise ValueError("palette contains raw palette data")
  79.         if type(fp) == type(""):
  80.             fp = open(fp, "w")
  81.         fp.write("# Palette\n")
  82.         fp.write("# Mode: %s\n" % self.mode)
  83.         for i in range(256):
  84.             fp.write("%d" % i)
  85.             for j in range(i, len(self.palette), 256):
  86.                 fp.write(" %d" % self.palette[j])
  87.             fp.write("\n")
  88.         fp.close()
  89.  
  90. # --------------------------------------------------------------------
  91. # Internal
  92.  
  93. def raw(rawmode, data):
  94.     palette = ImagePalette()
  95.     palette.rawmode = rawmode
  96.     palette.palette = data
  97.     palette.dirty = 1
  98.     return palette
  99.  
  100. # --------------------------------------------------------------------
  101. # Factories
  102.  
  103. def new(mode, data):
  104.     return Image.core.new_palette(mode, data)
  105.  
  106. def negative(mode = "RGB"):
  107.     palette = range(256)
  108.     palette.reverse()
  109.     return ImagePalette(mode, palette * len(mode))
  110.  
  111. def random(mode = "RGB"):
  112.     from random import randint
  113.     palette = map(lambda a, randint=randint:
  114.                   randint(0, 255), [0]*256*len(mode))
  115.     return ImagePalette(mode, palette)
  116.  
  117. def wedge(mode = "RGB"):
  118.     return ImagePalette(mode, range(256) * len(mode))
  119.  
  120. def load(filename):
  121.  
  122.     # FIXME: supports GIMP gradients only
  123.  
  124.     fp = open(filename, "rb")
  125.  
  126.     lut = None
  127.  
  128.     if not lut:
  129.         try:
  130.             import GimpPaletteFile
  131.             fp.seek(0)
  132.             p = GimpPaletteFile.GimpPaletteFile(fp)
  133.             lut = p.getpalette()
  134.         except (SyntaxError, ValueError):
  135.             pass
  136.  
  137.     if not lut:
  138.         try:
  139.             import GimpGradientFile
  140.             fp.seek(0)
  141.             p = GimpGradientFile.GimpGradientFile(fp)
  142.             lut = p.getpalette()
  143.         except (SyntaxError, ValueError):
  144.             pass
  145.  
  146.     if not lut:
  147.         try:
  148.             import PaletteFile
  149.             fp.seek(0)
  150.             p = PaletteFile.PaletteFile(fp)
  151.             lut = p.getpalette()
  152.         except (SyntaxError, ValueError):
  153.             pass
  154.  
  155.     if not lut:
  156.         raise IOError, "cannot load palette"
  157.  
  158.     return lut # data, rawmode
  159.  
  160.  
  161. # add some psuedocolour palettes as well
  162.