Python pil.Image类代码示例

	def setink(self, ink):
		# compatibility
		if warnings:
			warnings.warn(
				"'setink' is deprecated; use keyword arguments instead",
				DeprecationWarning, stacklevel=2
				)
		if Image.isStringType(ink):
			ink = ImageColor.getcolor(ink, self.mode)
		if self.palette and not Image.isNumberType(ink):
			ink = self.palette.getcolor(ink)
		self.ink = self.draw.draw_ink(ink, self.mode)

def open(filename):
	# FIXME: modify to return a WalImageFile instance instead of
	# plain Image object ?

	if hasattr(filename, "read"):
		fp = filename
	else:
		import __builtin__
		fp = __builtin__.open(filename, "rb")

	# read header fields
	header = fp.read(32+24+32+12)
	size = i32(header, 32), i32(header, 36)
	offset = i32(header, 40)

	# load pixel data
	fp.seek(offset)

	im = Image.fromstring("P", size, fp.read(size[0] * size[1]))
	im.putpalette(quake2palette)

	im.format = "WAL"
	im.format_description = "Quake2 Texture"

	# strings are null-terminated
	im.info["name"] = header[:32].split("\0", 1)[0]
	next_name = header[56:56+32].split("\0", 1)[0]
	if next_name:
		im.info["next_name"] = next_name

	return im

def grabclipboard():
	debug = 0 # temporary interface
	data = Image.core.grabclipboard(debug)
	if Image.isStringType(data):
		import BmpImagePlugin, StringIO
		return BmpImagePlugin.DibImageFile(StringIO.StringIO(data))
	return data

	def __fixup(self, im1):
		# convert image to suitable mode
		if isinstance(im1, _Operand):
			# argument was an image.
			if im1.im.mode in ("1", "L"):
				return im1.im.convert("I")
			elif im1.im.mode in ("I", "F"):
				return im1.im
			else:
				raise ValueError, "unsupported mode: %s" % im1.im.mode
		else:
			# argument was a constant
			if _isconstant(im1) and self.im.mode in ("1", "L", "I"):
				return Image.new("I", self.im.size, im1)
			else:
				return Image.new("F", self.im.size, im1)

		def load(self, im):
			im.fp.seek(0) # rewind
			return Image.fromstring(
				"RGB", im.size,
				Image.core.drawwmf(im.fp.read(), im.size, self.bbox),
				"raw", "BGR", (im.size[0]*3 + 3) & -4, -1
				)

	def __init__(self, im):

		data = None
		colortable = None

		# handle filename, if given instead of image name
		if hasattr(im, "toUtf8"):
			# FIXME - is this really the best way to do this?
			im = unicode(im.toUtf8(), "utf-8")
		if Image.isStringType(im):
			im = Image.open(im)

		if im.mode == "1":
			format = QImage.Format_Mono
		elif im.mode == "L":
			format = QImage.Format_Indexed8
			colortable = []
			for i in range(256):
				colortable.append(rgb(i, i, i))
		elif im.mode == "P":
			format = QImage.Format_Indexed8
			colortable = []
			palette = im.getpalette()
			for i in range(0, len(palette), 3):
				colortable.append(rgb(*palette[i:i+3]))
		elif im.mode == "RGB":
			data = im.tostring("raw", "BGRX")
			format = QImage.Format_RGB32
		elif im.mode == "RGBA":
			try:
				data = im.tostring("raw", "BGRA")
			except SystemError:
				# workaround for earlier versions
				r, g, b, a = im.split()
				im = Image.merge("RGBA", (b, g, r, a))
			format = QImage.Format_ARGB32
		else:
			raise ValueError("unsupported image mode %r" % im.mode)

		# must keep a reference, or Qt will crash!
		self.__data = data or im.tostring()

		QImage.__init__(self, self.__data, im.size[0], im.size[1], format)

		if colortable:
			self.setColorTable(colortable)

	def __init__(self, profile):
		# accepts a string (filename), a file-like object, or a low-level
		# profile object
		if Image.isStringType(profile):
			self._set(core.profile_open(profile), profile)
		elif hasattr(profile, "read"):
			self._set(core.profile_fromstring(profile.read()))
		else:
			self._set(profile) # assume it's already a profile

def load_path(filename):
	"Load a font file, searching along the Python path."
	for dir in sys.path:
		if Image.isDirectory(dir):
			try:
				return load(os.path.join(dir, filename))
			except IOError:
				pass
	raise IOError("cannot find font file")

def grab(bbox=None):
	size, data = grabber()
	im = Image.fromstring(
		"RGB", size, data,
		# RGB, 32-bit line padding, origo in lower left corner
		"raw", "BGR", (size[0]*3 + 3) & -4, -1
		)
	if bbox:
		im = im.crop(bbox)
	return im

def build_prototype_image():
	image = Image.new("L", (1,len(_Palm8BitColormapValues),))
	image.putdata(range(len(_Palm8BitColormapValues)))
	palettedata = ()
	for i in range(len(_Palm8BitColormapValues)):
		palettedata = palettedata + _Palm8BitColormapValues[i]
	for i in range(256 - len(_Palm8BitColormapValues)):
		palettedata = palettedata + (0, 0, 0)
	image.putpalette(palettedata)
	return image

	def _getink(self, ink, fill=None):
		if ink is None and fill is None:
			if self.fill:
				fill = self.ink
			else:
				ink = self.ink
		else:
			if ink is not None:
				if Image.isStringType(ink):
					ink = ImageColor.getcolor(ink, self.mode)
				if self.palette and not Image.isNumberType(ink):
					ink = self.palette.getcolor(ink)
				ink = self.draw.draw_ink(ink, self.mode)
			if fill is not None:
				if Image.isStringType(fill):
					fill = ImageColor.getcolor(fill, self.mode)
				if self.palette and not Image.isNumberType(fill):
					fill = self.palette.getcolor(fill)
				fill = self.draw.draw_ink(fill, self.mode)
		return ink, fill

def bdf_char(f):

	# skip to STARTCHAR
	while 1:
		s = f.readline()
		if not s:
			return None
		if s[:9] == "STARTCHAR":
			break
	id = string.strip(s[9:])

	# load symbol properties
	props = {}
	while 1:
		s = f.readline()
		if not s or s[:6] == "BITMAP":
			break
		i = string.find(s, " ")
		props[s[:i]] = s[i+1:-1]

	# load bitmap
	bitmap = []
	while 1:
		s = f.readline()
		if not s or s[:7] == "ENDCHAR":
			break
		bitmap.append(s[:-1])
	bitmap = string.join(bitmap, "")

	[x, y, l, d] = map(int, string.split(props["BBX"]))
	[dx, dy] = map(int, string.split(props["DWIDTH"]))

	bbox = (dx, dy), (l, -d-y, x+l, -d), (0, 0, x, y)

	try:
		im = Image.fromstring("1", (x, y), bitmap, "hex", "1")
	except ValueError:
		# deal with zero-width characters
		im = Image.new("1", (x, y))

	return id, int(props["ENCODING"]), bbox, im

def getcolor(color, mode):
	# same as getrgb, but converts the result to the given mode
	color = getrgb(color)
	if mode == "RGB":
		return color
	if mode == "RGBA":
		r, g, b = color
		return r, g, b, 255
	if Image.getmodebase(mode) == "L":
		r, g, b = color
		return (r*299 + g*587 + b*114)/1000
	return color

def _save(im, fp, tile):
    "Helper to save image based on tile list"

    im.load()
    if not hasattr(im, "encoderconfig"):
        im.encoderconfig = ()
    tile.sort(_tilesort)
    # FIXME: make MAXBLOCK a configuration parameter
    bufsize = max(MAXBLOCK, im.size[0] * 4)  # see RawEncode.c
    try:
        fh = fp.fileno()
        fp.flush()
    except AttributeError:
        # compress to Python file-compatible object
        for e, b, o, a in tile:
            e = Image._getencoder(im.mode, e, a, im.encoderconfig)
            if o > 0:
                fp.seek(o, 0)
            e.setimage(im.im, b)
            while 1:
                l, s, d = e.encode(bufsize)
                fp.write(d)
                if s:
                    break
            if s < 0:
                raise IOError("encoder error %d when writing image file" % s)
    else:
        # slight speedup: compress to real file object
        for e, b, o, a in tile:
            e = Image._getencoder(im.mode, e, a, im.encoderconfig)
            if o > 0:
                fp.seek(o, 0)
            e.setimage(im.im, b)
            s = e.encode_to_file(fh, bufsize)
            if s < 0:
                raise IOError("encoder error %d when writing image file" % s)
    try:
        fp.flush()
    except:
        pass

	def __init__(self, image, size=None):
		if hasattr(image, "mode") and hasattr(image, "size"):
			mode = image.mode
			size = image.size
		else:
			mode = image
			image = None
		if mode not in ["1", "L", "P", "RGB"]:
			mode = Image.getmodebase(mode)
		self.image = Image.core.display(mode, size)
		self.mode = mode
		self.size = size
		if image:
			self.paste(image)