if fourcc == b"DXT1": self.pixel_format = "DXT1" codec = _dxt1 elif fourcc == b"DXT5": self.pixel_format = "DXT5" codec = _dxt5 else: raise NotImplementedError("Unimplemented pixel format %r" % (fourcc)) try: decoded_data = codec(self.fp, self.width, self.height) except struct.error: raise IOError("Truncated DDS file") finally: self.fp.close() self.fp = BytesIO(decoded_data) def load_seek(self, pos): pass def _validate(prefix): return prefix[:4] == b"DDS " Image.register_open(DdsImageFile.format, DdsImageFile, _validate) Image.register_extension(DdsImageFile.format, ".dds")
rawmode = "F;32NF" # 32-bit native floating point ImageFile._save(im, fp, [("raw", (0, 0)+im.size, 0, (rawmode, 0, 1))]) fp.close() def _save_spider(im, fp, filename): # get the filename extension and register it with Image ext = os.path.splitext(filename)[1] Image.register_extension(SpiderImageFile.format, ext) _save(im, fp, filename) # -------------------------------------------------------------------- Image.register_open(SpiderImageFile.format, SpiderImageFile) Image.register_save(SpiderImageFile.format, _save_spider) if __name__ == "__main__": if not sys.argv[1:]: print("Syntax: python SpiderImagePlugin.py [infile] [outfile]") sys.exit() filename = sys.argv[1] if not isSpiderImage(filename): print("input image must be in Spider format") sys.exit() outfile = "" if len(sys.argv[1:]) > 1:
d = data[40:] #BGRA row_pixels = d[row_len*y:row_len*y+row_len] bit=0 byte=0 for x in xrange(im.size[0]): p=row_pixels[x] byte<<=1 bit+=1 if bit == 8: fp.write(o8(byte)) bit=0 byte=0 if not bit == 0: fp.write(o8(byte<<(8-bit))) for i in xrange(scanline_pad): fp.write(o8(0)) fp.flush() # # -------------------------------------------------------------------- Image.register_open(IcoFile.format, IcoImageFile, _accept) Image.register_save(IcoFile.format, _save) Image.register_extension(IcoFile.format, '.ico')
+ o16(offset[1]) # offset + o16(im.size[0]) + o16(im.size[1]) # size + o8(0) + o8(8) # flags ) # bits ImageFile._save(im, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im.mode])]) fp.write(b"\0") # end of image data finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open(GifImageFile.format, GifImageFile, _accept) Image.register_save(GifImageFile.format, _save) Image.register_extension(GifImageFile.format, ".gif") Image.register_mime(GifImageFile.format, "image/gif") # # Uncomment the following line if you wish to use NETPBM/PBMPLUS # instead of the built-in "uncompressed" GIF encoder # Image.register_save(GifImageFile.format, _save_netpbm)
self.tile = [("raw", (0, 0) + self.size, 0, self.mode)] def _save(im, fp, filename): quality = im.encoderinfo.get("quality", 80) if im.mode == "RGB": data = WebPEncodeRGB(im.tobytes(), im.size[0], im.size[1], im.size[0] * 3, float(quality)) elif im.mode == "RGBA": data = WebPEncodeRGBA(im.tobytes(), im.size[0], im.size[1], im.size[0] * 4, float(quality)) else: raise IOError("cannot write mode %s as WEBP" % im.mode) fp.write(data) def explicitRegisterOnPIL(ImageClass): """ Instead of monkeypatching on import, this function lets you send the PIL.Image class and explicitly register on it """ ImageClass.register_open("WEBP", WebPImageFile, _accept) ImageClass.register_save("WEBP", _save) ImageClass.register_extension("WEBP", ".webp") ImageClass.register_mime("WEBP", "image/webp") Image.register_open("WEBP", WebPImageFile, _accept) Image.register_save("WEBP", _save) Image.register_extension("WEBP", ".webp") Image.register_mime("WEBP", "image/webp")
elif layout == (1, 3, 4): self.mode = "RGBA" else: raise SyntaxError("unsupported SGI image mode") # size self.size = i16(s[6:]), i16(s[8:]) # decoder info if compression == 0: offset = 512 pagesize = self.size[0]*self.size[1]*layout[0] self.tile = [] for layer in self.mode: self.tile.append(("raw", (0,0)+self.size, offset, (layer,0,-1))) offset = offset + pagesize elif compression == 1: self.tile = [("sgi_rle", (0,0)+self.size, 512, (self.mode, 0, -1))] # # registry Image.register_open("SGI", SgiImageFile, _accept) Image.register_extension("SGI", ".bw") Image.register_extension("SGI", ".rgb") Image.register_extension("SGI", ".rgba") Image.register_extension("SGI", ".sgi") # really?
+ o32(0) # depth + o32(image) # compression (0=uncompressed) + o32(ppm[0]) # size of bitmap + o32(ppm[1]) + o32(colors) # resolution + o32(colors) # colors used ) # colors important fp.write(b"\0" * (header - 40)) # padding (for OS/2 format) if im.mode == "1": for i in (0, 255): fp.write(o8(i) * 4) elif im.mode == "L": for i in range(256): fp.write(o8(i) * 4) elif im.mode == "P": fp.write(im.im.getpalette("RGB", "BGRX")) ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))]) # # -------------------------------------------------------------------- # Registry Image.register_open(BmpImageFile.format, BmpImageFile, _accept) Image.register_save(BmpImageFile.format, _save) Image.register_extension(BmpImageFile.format, ".bmp")
from PIL import Image from PIL.PngImagePlugin import PngImageFile from io import BytesIO # SVG thumbnail generator try: from cairosvg.surface import PNGSurface def svg_image_factory(data, *args): png_data = PNGSurface.convert(data.read()) return PngImageFile(BytesIO(png_data)) Image.register_mime("SVG", "image/svg+xml") Image.register_extension("SVG", ".svg") Image.register_open("SVG", svg_image_factory) except Exception: pass # PSD thumbnail generator def psd_image_factory(data, *args): return PSDImage.from_stream(data).as_PIL() Image.init() Image.register_open("PSD", psd_image_factory) def get_thumbnail_url(file_obj, thumbnailer_size): # Ugly hack to temporary ignore tiff files
format = "PCD" format_description = "Kodak PhotoCD" def _open(self): # rough self.fp.seek(2048) s = self.fp.read(2048) if s[:4] != b"PCD_": raise SyntaxError("not a PCD file") orientation = i8(s[1538]) & 3 if orientation == 1: self.tile_post_rotate = 90 # hack elif orientation == 3: self.tile_post_rotate = -90 self.mode = "RGB" self.size = 768, 512 # FIXME: not correct for rotated images! self.tile = [("pcd", (0, 0) + self.size, 96 * 2048, None)] # # registry Image.register_open(PcdImageFile.format, PcdImageFile) Image.register_extension(PcdImageFile.format, ".pcd")
raise ValueError("Cannot save %s images as IM" % im.mode) try: frames = im.encoderinfo["frames"] except KeyError: frames = 1 if check: return check fp.write(("Image type: %s image\r\n" % type).encode('ascii')) if filename: fp.write(("Name: %s\r\n" % filename).encode('ascii')) fp.write(("Image size (x*y): %d*%d\r\n" % im.size).encode('ascii')) fp.write(("File size (no of images): %d\r\n" % frames).encode('ascii')) if im.mode == "P": fp.write(b"Lut: 1\r\n") fp.write(b"\000" * (511-fp.tell()) + b"\032") if im.mode == "P": fp.write(im.im.getpalette("RGB", "RGB;L")) # 768 bytes ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, -1))]) # # -------------------------------------------------------------------- # Registry Image.register_open("IM", ImImageFile) Image.register_save("IM", _save) Image.register_extension("IM", ".im")
if frame != self.__frame + 1: raise ValueError("cannot seek to frame %d" % frame) self.__frame = frame # move to next frame self.fp = self.__fp self.fp.seek(self.__offset) s = self.fp.read(4) if not s: raise EOFError framesize = i32(s) self.decodermaxblock = framesize self.tile = [("fli", (0, 0) + self.size, self.__offset, None)] self.__offset += framesize def tell(self): return self.__frame # # registry Image.register_open(FliImageFile.format, FliImageFile, _accept) Image.register_extension(FliImageFile.format, ".fli") Image.register_extension(FliImageFile.format, ".flc")
def append(self, chunk): self.data.append(chunk) def append(fp, cid, *data): data = b"".join(data) hi, lo = Image.core.crc32(data, Image.core.crc32(cid)) crc = o16(hi) + o16(lo) fp.append((cid, data, crc)) fp = collector() try: im.encoderinfo = params _save(im, fp, None, append) finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open("PNG", PngImageFile, _accept) Image.register_save("PNG", _save) Image.register_extension("PNG", ".png") Image.register_mime("PNG", "image/png")
# local image header fp.write(b"," + o16(offset[0]) + # offset o16(offset[1]) + o16(im.size[0]) + # size o16(im.size[1]) + o8(0) + # flags o8(8)) # bits ImageFile._save(im, fp, [("gif", (0, 0) + im.size, 0, RAWMODE[im.mode])]) fp.write(b"\0") # end of image data finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open(GifImageFile.format, GifImageFile, _accept) Image.register_save(GifImageFile.format, _save) Image.register_extension(GifImageFile.format, ".gif") Image.register_mime(GifImageFile.format, "image/gif") # # Uncomment the following line if you wish to use NETPBM/PBMPLUS # instead of the built-in "uncompressed" GIF encoder # Image.register_save(GifImageFile.format, _save_netpbm)
elif i8(s[0]) > i8(m[0]) and i8(s[1]) > i8(m[1]): m = s # print("width", i8(s[0])) # print("height", i8(s[1])) # print("colors", i8(s[2])) # print("reserved", i8(s[3])) # print("hotspot x", i16(s[4:])) # print("hotspot y", i16(s[6:])) # print("bytes", i32(s[8:])) # print("offset", i32(s[12:])) if not m: raise TypeError("No cursors were found") # load as bitmap self._bitmap(i32(m[12:]) + offset) # patch up the bitmap height self.size = self.size[0], self.size[1]//2 d, e, o, a = self.tile[0] self.tile[0] = d, (0, 0)+self.size, o, a return # # -------------------------------------------------------------------- Image.register_open(CurImageFile.format, CurImageFile, _accept) Image.register_extension(CurImageFile.format, ".cur")
fp.write( o8(10) + o8(version) + o8(1) + o8(bits) + o16(0) + o16(0) + o16(im.size[0]-1) + o16(im.size[1]-1) + o16(dpi[0]) + o16(dpi[1]) + b"\0"*24 + b"\xFF"*24 + b"\0" + o8(planes) + o16(stride) + o16(1) + o16(screen[0]) + o16(screen[1]) + b"\0"*54 ) assert fp.tell() == 128 ImageFile._save(im, fp, [("pcx", (0,0)+im.size, 0, (rawmode, bits*planes))]) if im.mode == "P": # colour palette fp.write(o8(12)) fp.write(im.im.getpalette("RGB", "RGB")) # 768 bytes elif im.mode == "L": # greyscale palette fp.write(o8(12)) for i in range(256): fp.write(o8(i)*3) # -------------------------------------------------------------------- # registry Image.register_open("PCX", PcxImageFile, _accept) Image.register_save("PCX", _save) Image.register_extension("PCX", ".pcx")
self.mode = rawmode = "L" elif depth == 24: self.mode, rawmode = "RGB", "BGR" else: raise SyntaxError("unsupported mode") compression = i32(s[20:24]) if i32(s[24:28]) != 0: length = i32(s[28:32]) offset = offset + length self.palette = ImagePalette.raw("RGB;L", self.fp.read(length)) if self.mode == "L": self.mode = rawmode = "P" stride = (((self.size[0] * depth + 7) // 8) + 3) & (~3) if compression == 1: self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride)) ] elif compression == 2: self.tile = [("sun_rle", (0, 0) + self.size, offset, rawmode)] # # registry Image.register_open(SunImageFile.format, SunImageFile, _accept) Image.register_extension(SunImageFile.format, ".ras")
if not _accept(self.fp.read(8)): raise SyntaxError("Not a BUFR file") self.fp.seek(offset) # make something up self.mode = "F" self.size = 1, 1 loader = self._load() if loader: loader.open(self) def _load(self): return _handler def _save(im, fp, filename): if _handler is None or not hasattr("_handler", "save"): raise IOError("BUFR save handler not installed") _handler.save(im, fp, filename) # -------------------------------------------------------------------- # Registry Image.register_open(BufrStubImageFile.format, BufrStubImageFile, _accept) Image.register_save(BufrStubImageFile.format, _save) Image.register_extension(BufrStubImageFile.format, ".bufr")
fp.writelines(hdr) rawmode = "F;32NF" # 32-bit native floating point ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))]) def _save_spider(im, fp, filename): # get the filename extension and register it with Image ext = os.path.splitext(filename)[1] Image.register_extension(SpiderImageFile.format, ext) _save(im, fp, filename) # -------------------------------------------------------------------- Image.register_open(SpiderImageFile.format, SpiderImageFile) Image.register_save(SpiderImageFile.format, _save_spider) if __name__ == "__main__": if len(sys.argv) < 2: print("Syntax: python SpiderImagePlugin.py [infile] [outfile]") sys.exit() filename = sys.argv[1] if not isSpiderImage(filename): print("input image must be in Spider format") sys.exit() im = Image.open(filename) print("image: " + str(im))
self.tile = [("xbm", (0, 0)+self.size, m.end(), None)] def _save(im, fp, filename): if im.mode != "1": raise IOError("cannot write mode %s as XBM" % im.mode) fp.write(("#define im_width %d\n" % im.size[0]).encode('ascii')) fp.write(("#define im_height %d\n" % im.size[1]).encode('ascii')) hotspot = im.encoderinfo.get("hotspot") if hotspot: fp.write(("#define im_x_hot %d\n" % hotspot[0]).encode('ascii')) fp.write(("#define im_y_hot %d\n" % hotspot[1]).encode('ascii')) fp.write(b"static char im_bits[] = {\n") ImageFile._save(im, fp, [("xbm", (0, 0)+im.size, 0, None)]) fp.write(b"};\n") Image.register_open("XBM", XbmImageFile, _accept) Image.register_save("XBM", _save) Image.register_extension("XBM", ".xbm") Image.register_mime("XBM", "image/xbm")
self.mode = rawmode = "L" elif depth == 24: self.mode, rawmode = "RGB", "BGR" else: raise SyntaxError("unsupported mode") compression = i32(s[20:24]) if i32(s[24:28]) != 0: length = i32(s[28:32]) offset = offset + length self.palette = ImagePalette.raw("RGB;L", self.fp.read(length)) if self.mode == "L": self.mode = rawmode = "P" stride = (((self.size[0] * depth + 7) // 8) + 3) & (~3) if compression == 1: self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride)) ] elif compression == 2: self.tile = [("sun_rle", (0, 0) + self.size, offset, rawmode)] # # registry Image.register_open("SUN", SunImageFile, _accept) Image.register_extension("SUN", ".ras")
pass def append(self, chunk): self.data.append(chunk) def append(fp, cid, *data): data = b"".join(data) hi, lo = Image.core.crc32(data, Image.core.crc32(cid)) crc = o16(hi) + o16(lo) fp.append((cid, data, crc)) fp = collector() try: im.encoderinfo = params _save(im, fp, None, append) finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open("PNG", PngImageFile, _accept) Image.register_save("PNG", _save) Image.register_extension("PNG", ".png") Image.register_mime("PNG", "image/png")
o32(image) + # size of bitmap o32(ppm[0]) + o32(ppm[1]) + # resolution o32(colors) + # colors used o32(colors)) # colors important fp.write(b"\0" * (header - 40)) # padding (for OS/2 format) if im.mode == "1": for i in (0, 255): fp.write(o8(i) * 4) elif im.mode == "L": for i in range(256): fp.write(o8(i) * 4) elif im.mode == "P": fp.write(im.im.getpalette("RGB", "BGRX")) ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, stride, -1))]) # # -------------------------------------------------------------------- # Registry Image.register_open(BmpImageFile.format, BmpImageFile, _accept) Image.register_save(BmpImageFile.format, _save) Image.register_extension(BmpImageFile.format, ".bmp") Image.register_mime(BmpImageFile.format, "image/bmp")
# read key/value pair # FIXME: dangerous, may read whole file s = s + self.fp.readline() if len(s) == 1 or len(s) > 100: break if s[0] == b"*": continue # comment m = field.match(s) if not m: break k, v = m.group(1,2) if k == "width": xsize = int(v) self.size = xsize, ysize elif k == "height": ysize = int(v) self.size = xsize, ysize elif k == "pixel" and v == "n8": self.mode = "L" # # -------------------------------------------------------------------- Image.register_open("IMT", ImtImageFile) # # no extension registered (".im" is simply too common)
# # image header fp.write("gsave\n") fp.write("10 dict begin\n") fp.write("/buf %d string def\n" % (im.size[0] * operator[1])) fp.write("%d %d scale\n" % im.size) fp.write("%d %d 8\n" % im.size) # <= bits fp.write("[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1])) fp.write("{ currentfile buf readhexstring pop } bind\n") fp.write(operator[2] + "\n") fp.flush() ImageFile._save(im, base_fp, [("eps", (0, 0) + im.size, 0, None)]) fp.write("\n%%%%EndBinary\n") fp.write("grestore end\n") fp.flush() # # -------------------------------------------------------------------- Image.register_open(EpsImageFile.format, EpsImageFile, _accept) Image.register_save(EpsImageFile.format, _save) Image.register_extension(EpsImageFile.format, ".ps") Image.register_extension(EpsImageFile.format, ".eps") Image.register_mime(EpsImageFile.format, "application/postscript")
# Ensure that our buffer is big enough bufsize = max(ImageFile.MAXBLOCK, bufsize, len(info.get("exif", b"")) + 5) ImageFile._save(im, fp, [("jpeg", (0, 0) + im.size, 0, rawmode)], bufsize) def _save_cjpeg(im, fp, filename): # ALTERNATIVE: handle JPEGs via the IJG command line utilities. import os file = im._dump() os.system("cjpeg %s >%s" % (file, filename)) try: os.unlink(file) except: pass # -------------------------------------------------------------------q- # Registry stuff Image.register_open("JPEG", JpegImageFile, _accept) Image.register_save("JPEG", _save) Image.register_extension("JPEG", ".jfif") Image.register_extension("JPEG", ".jpe") Image.register_extension("JPEG", ".jpg") Image.register_extension("JPEG", ".jpeg") Image.register_mime("JPEG", "image/jpeg")
self.mode = "RGBA" else: raise ValueError("Unsupported SGI image mode") # size self.size = i16(s[6:]), i16(s[8:]) # decoder info if compression == 0: offset = 512 pagesize = self.size[0]*self.size[1]*layout[0] self.tile = [] for layer in self.mode: self.tile.append( ("raw", (0, 0)+self.size, offset, (layer, 0, -1))) offset = offset + pagesize elif compression == 1: raise ValueError("SGI RLE encoding not supported") # # registry Image.register_open("SGI", SgiImageFile, _accept) Image.register_extension("SGI", ".bw") Image.register_extension("SGI", ".rgb") Image.register_extension("SGI", ".rgba") Image.register_extension("SGI", ".sgi") # End of file
def append(self, chunk): self.data.append(chunk) def append(fp, cid, *data): data = b"".join(data) hi, lo = Image.core.crc32(data, Image.core.crc32(cid)) crc = o16(hi) + o16(lo) fp.append((cid, data, crc)) fp = collector() try: im.encoderinfo = params _save(im, fp, None, append) finally: del im.encoderinfo return fp.data # -------------------------------------------------------------------- # Registry Image.register_open(PngImageFile.format, PngImageFile, _accept) Image.register_save(PngImageFile.format, _save) Image.register_extension(PngImageFile.format, ".png") Image.register_mime(PngImageFile.format, "image/png")
class WebPImageFile(ImageFile.ImageFile): format = "WEBP" format_description = "WebP image" def _open(self): self.mode = "RGB" data, width, height = _webp.WebPDecodeRGB(self.fp.read()) self.size = width, height self.fp = BytesIO(data) self.tile = [("raw", (0, 0) + self.size, 0, 'RGB')] def _save(im, fp, filename): if im.mode != "RGB": raise IOError("cannot write mode %s as WEBP" % im.mode) quality = im.encoderinfo.get("quality", 80) data = _webp.WebPEncodeRGB(im.tostring(), im.size[0], im.size[1], im.size[0] * 3, float(quality)) fp.write(data) Image.register_open("WEBP", WebPImageFile, _accept) Image.register_save("WEBP", _save) Image.register_extension("WEBP", ".webp") Image.register_mime("WEBP", "image/webp")
if orientation > 0: flags = flags | 0x20 fp.write(b"\000" + o8(colormaptype) + o8(imagetype) + o16(colormapfirst) + o16(colormaplength) + o8(colormapentry) + o16(0) + o16(0) + o16(im.size[0]) + o16(im.size[1]) + o8(bits) + o8(flags)) if colormaptype: fp.write(im.im.getpalette("RGB", "BGR")) ImageFile._save( im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, orientation))]) # # -------------------------------------------------------------------- # Registry Image.register_open(TgaImageFile.format, TgaImageFile) Image.register_save(TgaImageFile.format, _save) Image.register_extension(TgaImageFile.format, ".tga")
rawmode = "F;32NF" #32-bit native floating point ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))]) fp.close() def _save_spider(im, fp, filename): # get the filename extension and register it with Image fn, ext = os.path.splitext(filename) Image.register_extension("SPIDER", ext) _save(im, fp, filename) # -------------------------------------------------------------------- Image.register_open("SPIDER", SpiderImageFile) #Image.register_extension("SPIDER", ".spi") Image.register_save("SPIDER", _save_spider) if __name__ == "__main__": if not sys.argv[1:]: print "Syntax: python SpiderImagePlugin.py Spiderimage [outfile]" sys.exit() filename = sys.argv[1] if not isSpiderImage(filename): print "input image must be in Spider format" sys.exit() outfile = ""
if not m: m = s elif ord(s[0]) > ord(m[0]) and ord(s[1]) > ord(m[1]): m = s #print "width", ord(s[0]) #print "height", ord(s[1]) #print "colors", ord(s[2]) #print "reserved", ord(s[3]) #print "hotspot x", i16(s[4:]) #print "hotspot y", i16(s[6:]) #print "bytes", i32(s[8:]) #print "offset", i32(s[12:]) # load as bitmap self._bitmap(i32(m[12:]) + offset) # patch up the bitmap height self.size = self.size[0], self.size[1]/2 d, e, o, a = self.tile[0] self.tile[0] = d, (0,0)+self.size, o, a return # # -------------------------------------------------------------------- Image.register_open("CUR", CurImageFile, _accept) Image.register_extension("CUR", ".cur")
try: # fast self.im = Image.core.open_ppm(outfile) except: # slightly slower im = Image.open(outfile) im.load() self.im = im.im finally: try: os.unlink(outfile) except: pass Image.register_open("IPTC", IptcImageFile) Image.register_extension("IPTC", ".iim") ## # Get IPTC information from TIFF, JPEG, or IPTC file. # # @param im An image containing IPTC data. # @return A dictionary containing IPTC information, or None if # no IPTC information block was found. def getiptcinfo(im): from PIL import TiffImagePlugin, JpegImagePlugin import io
try: try: # fast self.im = Image.core.open_ppm(outfile) except: # slightly slower im = Image.open(outfile) im.load() self.im = im.im finally: try: os.unlink(outfile) except: pass Image.register_open("IPTC", IptcImageFile) Image.register_extension("IPTC", ".iim") ## # Get IPTC information from TIFF, JPEG, or IPTC file. # # @param im An image containing IPTC data. # @return A dictionary containing IPTC information, or None if # no IPTC information block was found. def getiptcinfo(im): import StringIO data = None
convert_cmd = ["iconutil", "-c", "icns", "-o", filename, iconset] with open(os.devnull, 'wb') as devnull: convert_proc = Popen(convert_cmd, stdout=PIPE, stderr=devnull) convert_proc.stdout.close() retcode = convert_proc.wait() # remove the temporary files shutil.rmtree(iconset) if retcode: raise CalledProcessError(retcode, convert_cmd) Image.register_open(IcnsImageFile.format, IcnsImageFile, lambda x: x[:4] == b'icns') Image.register_extension(IcnsImageFile.format, '.icns') if sys.platform == 'darwin': Image.register_save(IcnsImageFile.format, _save) Image.register_mime(IcnsImageFile.format, "image/icns") if __name__ == '__main__': if len(sys.argv) < 2: print("Syntax: python IcnsImagePlugin.py [file]") sys.exit() imf = IcnsImageFile(open(sys.argv[1], 'rb')) for size in imf.info['sizes']:
if not _fp: fp.write(d) if s: break if s < 0: raise IOError("encoder error %d when writing image file" % s) else: offset = ifd.save(fp) ImageFile._save(im, fp, [ ("raw", (0, 0)+im.size, offset, (rawmode, stride, 1)) ]) # -- helper for multi-page save -- if "_debug_multipage" in im.encoderinfo: # just to access o32 and o16 (using correct byte order) im._debug_multipage = ifd # # -------------------------------------------------------------------- # Register Image.register_open("TIFF", TiffImageFile, _accept) Image.register_save("TIFF", _save) Image.register_extension("TIFF", ".tif") Image.register_extension("TIFF", ".tiff") Image.register_mime("TIFF", "image/tiff")
return len(self.images) @property def is_animated(self): return len(self.images) > 1 def seek(self, frame): try: filename = self.images[frame] except IndexError: raise EOFError("no such frame") self.fp = self.ole.openstream(filename) TiffImagePlugin.TiffImageFile._open(self) self.frame = frame def tell(self): return self.frame # # -------------------------------------------------------------------- Image.register_open(MicImageFile.format, MicImageFile, _accept) Image.register_extension(MicImageFile.format, ".mic")
self.mode = "RGB" self.size = 768, 512 # FIXME: not correct for rotated images! self.tile = [("pcd", (0,0)+self.size, 96*2048, None)] def draft(self, mode, size): if len(self.tile) != 1: return d, e, o, a = self.tile[0] if size: scale = max(self.size[0] / size[0], self.size[1] / size[1]) for s, o in [(4,0*2048), (2,0*2048), (1,96*2048)]: if scale >= s: break # e = e[0], e[1], (e[2]-e[0]+s-1)/s+e[0], (e[3]-e[1]+s-1)/s+e[1] # self.size = ((self.size[0]+s-1)/s, (self.size[1]+s-1)/s) self.tile = [(d, e, o, a)] return self # # registry Image.register_open("PCD", PcdImageFile) Image.register_extension("PCD", ".pcd")
""" format = "ICO" format_description = "Windows Icon" def _open(self): self.ico = IcoFile(self.fp) self.info['sizes'] = self.ico.sizes() self.size = self.ico.entry[0]['dim'] self.load() def load(self): im = self.ico.getimage(self.size) # if tile is PNG, it won't really be loaded yet im.load() self.im = im.im self.mode = im.mode self.size = im.size def load_seek(self): # Flag the ImageFile.Parser so that it # just does all the decode at the end. pass # # -------------------------------------------------------------------- Image.register_open(IcoImageFile.format, IcoImageFile, _accept) Image.register_save(IcoImageFile.format, _save) Image.register_extension(IcoImageFile.format, ".ico")
# -------------------------------------------------------------------- def _save(im, fp, filename): if im.mode == "1": rawmode, head = "1;I", b"P4" elif im.mode == "L": rawmode, head = "L", b"P5" elif im.mode == "RGB": rawmode, head = "RGB", b"P6" elif im.mode == "RGBA": rawmode, head = "RGB", b"P6" else: raise IOError("cannot write mode %s as PPM" % im.mode) fp.write(head + ("\n%d %d\n" % im.size).encode('ascii')) if head != b"P4": fp.write(b"255\n") ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, 1))]) # ALTERNATIVE: save via builtin debug function # im._dump(filename) # # -------------------------------------------------------------------- Image.register_open("PPM", PpmImageFile, _accept) Image.register_save("PPM", _save) Image.register_extension("PPM", ".pbm") Image.register_extension("PPM", ".pgm") Image.register_extension("PPM", ".ppm")
if jpeg_tables: self.tile_prefix = self.jpeg[jpeg_tables] else: raise IOError("unknown/invalid compression") x = x + xtile if x >= xsize: x, y = 0, y + ytile if y >= ysize: break # isn't really required self.stream = stream self.fp = None def load(self): if not self.fp: self.fp = self.ole.openstream(self.stream[:2] + ["Subimage 0000 Data"]) ImageFile.ImageFile.load(self) # # -------------------------------------------------------------------- Image.register_open("FPX", FpxImageFile, _accept) Image.register_extension("FPX", ".fpx")
self.mode = "P" self.palette = ImagePalette.raw("RGB", b"".join(palette)) self.tile = [("raw", (0, 0)+self.size, self.fp.tell(), ("P", 0, 1))] def load_read(self, bytes): # # load all image data in one chunk xsize, ysize = self.size s = [None] * ysize for i in range(ysize): s[i] = self.fp.readline()[1:xsize+1].ljust(xsize) self.fp = None return b"".join(s) # # Registry Image.register_open("XPM", XpmImageFile, _accept) Image.register_extension("XPM", ".xpm") Image.register_mime("XPM", "image/xpm")
# PCX header fp.write( o8(10) + o8(version) + o8(1) + o8(bits) + o16(0) + o16(0) + o16(im.size[0] - 1) + o16(im.size[1] - 1) + o16(dpi[0]) + o16(dpi[1]) + b"\0" * 24 + b"\xFF" * 24 + b"\0" + o8(planes) + o16(stride) + o16(1) + o16(screen[0]) + o16(screen[1]) + b"\0" * 54) assert fp.tell() == 128 ImageFile._save(im, fp, [("pcx", (0, 0) + im.size, 0, (rawmode, bits * planes))]) if im.mode == "P": # colour palette fp.write(o8(12)) fp.write(im.im.getpalette("RGB", "RGB")) # 768 bytes elif im.mode == "L": # greyscale palette fp.write(o8(12)) for i in range(256): fp.write(o8(i) * 3) # -------------------------------------------------------------------- # registry Image.register_open(PcxImageFile.format, PcxImageFile, _accept) Image.register_save(PcxImageFile.format, _save) Image.register_extension(PcxImageFile.format, ".pcx")
if not _fp: fp.write(d) if s: break if s < 0: raise IOError("encoder error %d when writing image file" % s) else: offset = ifd.save(fp) ImageFile._save(im, fp, [ ("raw", (0, 0)+im.size, offset, (rawmode, stride, 1)) ]) # -- helper for multi-page save -- if "_debug_multipage" in im.encoderinfo: # just to access o32 and o16 (using correct byte order) im._debug_multipage = ifd # # -------------------------------------------------------------------- # Register Image.register_open(TiffImageFile.format, TiffImageFile, _accept) Image.register_save(TiffImageFile.format, _save) Image.register_extension(TiffImageFile.format, ".tif") Image.register_extension(TiffImageFile.format, ".tiff") Image.register_mime(TiffImageFile.format, "image/tiff")
class PcdImageFile(ImageFile.ImageFile): format = "PCD" format_description = "Kodak PhotoCD" def _open(self): # rough self.fp.seek(2048) s = self.fp.read(2048) if s[:4] != b"PCD_": raise SyntaxError("not a PCD file") orientation = i8(s[1538]) & 3 if orientation == 1: self.tile_post_rotate = 90 # hack elif orientation == 3: self.tile_post_rotate = -90 self.mode = "RGB" self.size = 768, 512 # FIXME: not correct for rotated images! self.tile = [("pcd", (0, 0)+self.size, 96*2048, None)] # # registry Image.register_open("PCD", PcdImageFile) Image.register_extension("PCD", ".pcd")
# # packbits compression i = 0 tile = [] bytecount = read(channels * ysize * 2) offset = file.tell() for channel in range(channels): layer = mode[channel] if mode == "CMYK": layer = layer + ";I" tile.append( ("packbits", bbox, offset, layer) ) for y in range(ysize): offset = offset + i16(bytecount[i:i+2]) i = i + 2 file.seek(offset) if offset & 1: read(1) # padding return tile # -------------------------------------------------------------------- # registry Image.register_open("PSD", PsdImageFile, _accept) Image.register_extension("PSD", ".psd")
tile_offset, tile_size, quality_mode, quality_layers, num_resolutions, cblk_size, precinct_size, irreversible, progression, cinema_mode, fd ) ImageFile._save(im, fp, [('jpeg2k', (0, 0)+im.size, 0, kind)]) # ------------------------------------------------------------ # Registry stuff Image.register_open('JPEG2000', Jpeg2KImageFile, _accept) Image.register_save('JPEG2000', _save) Image.register_extension('JPEG2000', '.jp2') Image.register_extension('JPEG2000', '.j2k') Image.register_extension('JPEG2000', '.jpc') Image.register_extension('JPEG2000', '.jpf') Image.register_extension('JPEG2000', '.jpx') Image.register_extension('JPEG2000', '.j2c') Image.register_mime('JPEG2000', 'image/jp2') Image.register_mime('JPEG2000', 'image/jpx')
def _init_plugin(): if _getloader() is None: return Image.register_open(FlifImageFile.format, FlifImageFile, _accept) Image.register_extension(FlifImageFile.format, '.flif') Image.register_mime(FlifImageFile.format, 'image/flif')
def jpeg_factory(fp=None, filename=None): im = JpegImageFile(fp, filename) try: mpheader = im._getmp() if mpheader[45057] > 1: # It's actually an MPO from .MpoImagePlugin import MpoImageFile im = MpoImageFile(fp, filename) except (TypeError, IndexError): # It is really a JPEG pass except SyntaxError: warnings.warn("Image appears to be a malformed MPO file, it will be " "interpreted as a base JPEG file") pass return im # -------------------------------------------------------------------q- # Registry stuff Image.register_open(JpegImageFile.format, jpeg_factory, _accept) Image.register_save(JpegImageFile.format, _save) Image.register_extension(JpegImageFile.format, ".jfif") Image.register_extension(JpegImageFile.format, ".jpe") Image.register_extension(JpegImageFile.format, ".jpg") Image.register_extension(JpegImageFile.format, ".jpeg") Image.register_mime(JpegImageFile.format, "image/jpeg")
# get mode if w[11] == 1: mode = rawmode = "L" elif w[11] == 2: # FIXME: add memory map support mode = "I" rawmode = "I;16B" elif w[11] == 4: # FIXME: add memory map support mode = "I" rawmode = "I;32B" else: raise SyntaxError("unsupported McIdas format") self.mode = mode self.size = w[10], w[9] offset = w[34] + w[15] stride = w[15] + w[10] * w[11] * w[14] self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride, 1))] # -------------------------------------------------------------------- # registry Image.register_open("MCIDAS", McIdasImageFile, _accept) # no default extension
try: # fast self.im = Image.core.open_ppm(outfile) except: # slightly slower im = Image.open(outfile) im.load() self.im = im.im finally: try: os.unlink(outfile) except: pass Image.register_open(IptcImageFile.format, IptcImageFile) Image.register_extension(IptcImageFile.format, ".iim") ## # Get IPTC information from TIFF, JPEG, or IPTC file. # # @param im An image containing IPTC data. # @return A dictionary containing IPTC information, or None if # no IPTC information block was found. def getiptcinfo(im): from PIL import TiffImagePlugin, JpegImagePlugin
# include SIMPLE, BITPIX, NAXIS, etc. self.fp.seek(offset) # make something up self.mode = "F" self.size = 1, 1 loader = self._load() if loader: loader.open(self) def _load(self): return _handler def _save(im, fp, filename): if _handler is None or not hasattr("_handler", "save"): raise IOError("FITS save handler not installed") _handler.save(im, fp, filename) # -------------------------------------------------------------------- # Registry Image.register_open(FITSStubImageFile.format, FITSStubImageFile, _accept) Image.register_save(FITSStubImageFile.format, _save) Image.register_extension(FITSStubImageFile.format, ".fit") Image.register_extension(FITSStubImageFile.format, ".fits")
if s != "P7 332": raise SyntaxError, "not an XV thumbnail file" # Skip to beginning of next line self.fp.readline() # skip info comments while 1: s = self.fp.readline() if not s: raise SyntaxError, "Unexpected EOF reading XV thumbnail file" if s[0] != '#': break # parse header line (already read) s = string.split(s.strip()) self.mode = "P" self.size = int(s[0]), int(s[1]) self.palette = ImagePalette.raw("RGB", PALETTE) self.tile = [ ("raw", (0, 0)+self.size, self.fp.tell(), (self.mode, 0, 1) )] # -------------------------------------------------------------------- Image.register_open("XVThumb", XVThumbImageFile)
fp.write( o8(10) + o8(version) + o8(1) + o8(bits) + o16(0) + o16(0) + o16(im.size[0]-1) + o16(im.size[1]-1) + o16(dpi[0]) + o16(dpi[1]) + b"\0"*24 + b"\xFF"*24 + b"\0" + o8(planes) + o16(stride) + o16(1) + o16(screen[0]) + o16(screen[1]) + b"\0"*54 ) assert fp.tell() == 128 ImageFile._save(im, fp, [("pcx", (0, 0)+im.size, 0, (rawmode, bits*planes))]) if im.mode == "P": # colour palette fp.write(o8(12)) fp.write(im.im.getpalette("RGB", "RGB")) # 768 bytes elif im.mode == "L": # greyscale palette fp.write(o8(12)) for i in range(256): fp.write(o8(i)*3) # -------------------------------------------------------------------- # registry Image.register_open("PCX", PcxImageFile, _accept) Image.register_save("PCX", _save) Image.register_extension("PCX", ".pcx")
if self.fp.read(6) != _MAGIC: raise SyntaxError("not an XV thumbnail file") # Skip to beginning of next line self.fp.readline() # skip info comments while True: s = self.fp.readline() if not s: raise SyntaxError("Unexpected EOF reading XV thumbnail file") if s[0] != b'#': break # parse header line (already read) s = s.strip().split() self.mode = "P" self.size = int(s[0:1]), int(s[1:2]) self.palette = ImagePalette.raw("RGB", PALETTE) self.tile = [ ("raw", (0, 0)+self.size, self.fp.tell(), (self.mode, 0, 1) )] # -------------------------------------------------------------------- Image.register_open(XVThumbImageFile.format, XVThumbImageFile, _accept)
# arg = ratio self.tile = [("wsq",(0, 0)+self.size,0,(12,))] def load_read(self, bytes): # may be overridden for blocked formats (e.g. PNG) # for WSQ, one block only. We can safely close the stream ret = self.fp.read() self.fp.close() return ret #______________________________________________________________________________ # Write WSQ image def _save(im, fp, filename, check=0,*args,**kw): if im.mode!='L': raise IOError("cannot write mode %s as WSQ" % im.mode) if check: return check # 12 is the ratio we want ImageFile._save(im, fp, [("wsq", (0,0)+im.size, 0, (12,))]) #______________________________________________________________________________ # Registry Image.register_open(WsqImageFile.format, WsqImageFile, _accept) Image.register_save(WsqImageFile.format, _save) Image.register_extension(WsqImageFile.format, ".wsq")
<*****@*****.**>. https://code.google.com/p/casadebender/wiki/Win32IconImagePlugin """ format = "ICO" format_description = "Windows Icon" def _open(self): self.ico = IcoFile(self.fp) self.info['sizes'] = self.ico.sizes() self.size = self.ico.entry[0]['dim'] self.load() def load(self): im = self.ico.getimage(self.size) # if tile is PNG, it won't really be loaded yet im.load() self.im = im.im self.mode = im.mode self.size = im.size def load_seek(self): # Flage the ImageFile.Parser so that it # just does all the decode at the end. pass # # -------------------------------------------------------------------- Image.register_open("ICO", IcoImageFile, _accept) Image.register_save("ICO", _save) Image.register_extension("ICO", ".ico")
self.area_descriptor_raw = s self.area_descriptor = w = [0] + list(struct.unpack("!64i", s)) # get mode if w[11] == 1: mode = rawmode = "L" elif w[11] == 2: # FIXME: add memory map support mode = "I"; rawmode = "I;16B" elif w[11] == 4: # FIXME: add memory map support mode = "I"; rawmode = "I;32B" else: raise SyntaxError("unsupported McIdas format") self.mode = mode self.size = w[10], w[9] offset = w[34] + w[15] stride = w[15] + w[10]*w[11]*w[14] self.tile = [("raw", (0, 0) + self.size, offset, (rawmode, stride, 1))] # -------------------------------------------------------------------- # registry Image.register_open("MCIDAS", McIdasImageFile, _accept) # no default extension
# # image header fp.write("gsave\n") fp.write("10 dict begin\n") fp.write("/buf %d string def\n" % (im.size[0] * operator[1])) fp.write("%d %d scale\n" % im.size) fp.write("%d %d 8\n" % im.size) # <= bits fp.write("[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1])) fp.write("{ currentfile buf readhexstring pop } bind\n") fp.write(operator[2] + "\n") fp.flush() ImageFile._save(im, base_fp, [("eps", (0, 0)+im.size, 0, None)]) fp.write("\n%%%%EndBinary\n") fp.write("grestore end\n") fp.flush() # # -------------------------------------------------------------------- Image.register_open(EpsImageFile.format, EpsImageFile, _accept) Image.register_save(EpsImageFile.format, _save) Image.register_extension(EpsImageFile.format, ".ps") Image.register_extension(EpsImageFile.format, ".eps") Image.register_mime(EpsImageFile.format, "application/postscript")
# Factory for making JPEG and MPO instances def jpeg_factory(fp=None, filename=None): im = JpegImageFile(fp, filename) try: mpheader = im._getmp() if mpheader[45057] > 1: # It's actually an MPO from .MpoImagePlugin import MpoImageFile im = MpoImageFile(fp, filename) except (TypeError, IndexError): # It is really a JPEG pass except SyntaxError: warnings.warn("Image appears to be a malformed MPO file, it will be " "interpreted as a base JPEG file") return im # -------------------------------------------------------------------q- # Registry stuff Image.register_open(JpegImageFile.format, jpeg_factory, _accept) Image.register_save(JpegImageFile.format, _save) Image.register_extension(JpegImageFile.format, ".jfif") Image.register_extension(JpegImageFile.format, ".jpe") Image.register_extension(JpegImageFile.format, ".jpg") Image.register_extension(JpegImageFile.format, ".jpeg") Image.register_mime(JpegImageFile.format, "image/jpeg")