← Back to branch summary

~ubuntu-branches/ubuntu/saucy/python-imaging/saucy-proposed

« back to all changes in this revision

Viewing changes to .pc/git-updates.diff/PIL/ImagePalette.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-01-31 20:49:20 UTC
  • mfrom: (27.1.1 raring-proposed)
  • Revision ID: package-import@ubuntu.com-20130131204920-b5zshy6vgfvdionl
Tags: 1.1.7+1.7.8-1ubuntu1
Rewrite build dependencies to allow cross builds.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/git-updates.diff/PIL/ImagePalette.py
 
1
#
 
2
# The Python Imaging Library.
 
3
# $Id$
 
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, ImageColor
 
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 contents 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 _make_linear_lut(black, white):
 
104
    lut = []
 
105
    if black == 0:
 
106
        for i in range(256):
 
107
            lut.append(white*i/255)
 
108
    else:
 
109
        raise NotImplementedError # FIXME
 
110
    return lut
 
111
 
 
112
def _make_gamma_lut(exp, mode="RGB"):
 
113
    lut = []
 
114
    for i in range(256):
 
115
        lut.append(int(((i / 255.0) ** exp) * 255.0 + 0.5))
 
116
    return lut
 
117
 
 
118
def new(mode, data):
 
119
    return Image.core.new_palette(mode, data)
 
120
 
 
121
def negative(mode="RGB"):
 
122
    palette = range(256)
 
123
    palette.reverse()
 
124
    return ImagePalette(mode, palette * len(mode))
 
125
 
 
126
def random(mode="RGB"):
 
127
    from random import randint
 
128
    palette = []
 
129
    for i in range(256*len(mode)):
 
130
        palette.append(randint(0, 255))
 
131
    return ImagePalette(mode, palette)
 
132
 
 
133
def sepia(white="#fff0c0"):
 
134
    r, g, b = ImageColor.getrgb(white)
 
135
    r = _make_linear_lut(0, r)
 
136
    g = _make_linear_lut(0, g)
 
137
    b = _make_linear_lut(0, b)
 
138
    return ImagePalette("RGB", r + g + b)
 
139
 
 
140
def wedge(mode="RGB"):
 
141
    return ImagePalette(mode, range(256) * len(mode))
 
142
 
 
143
def load(filename):
 
144
 
 
145
    # FIXME: supports GIMP gradients only
 
146
 
 
147
    fp = open(filename, "rb")
 
148
 
 
149
    lut = None
 
150
 
 
151
    if not lut:
 
152
        try:
 
153
            import GimpPaletteFile
 
154
            fp.seek(0)
 
155
            p = GimpPaletteFile.GimpPaletteFile(fp)
 
156
            lut = p.getpalette()
 
157
        except (SyntaxError, ValueError):
 
158
            pass
 
159
 
 
160
    if not lut:
 
161
        try:
 
162
            import GimpGradientFile
 
163
            fp.seek(0)
 
164
            p = GimpGradientFile.GimpGradientFile(fp)
 
165
            lut = p.getpalette()
 
166
        except (SyntaxError, ValueError):
 
167
            pass
 
168
 
 
169
    if not lut:
 
170
        try:
 
171
            import PaletteFile
 
172
            fp.seek(0)
 
173
            p = PaletteFile.PaletteFile(fp)
 
174
            lut = p.getpalette()
 
175
        except (SyntaxError, ValueError):
 
176
            pass
 
177
 
 
178
    if not lut:
 
179
        raise IOError, "cannot load palette"
 
180
 
 
181
    return lut # data, rawmode
 
182
 
 
183
 
 
184
# add some psuedocolour palettes as well