def _save(im, fp, filename):
if _imaging_gif:
# call external driver
try:
_imaging_gif.save(im, fp, filename)
return
except IOError:
pass # write uncompressed file
try:
rawmode = RAWMODE[im.mode]
imOut = im
except KeyError:
# convert on the fly (EXPERIMENTAL -- I'm not sure PIL
# should automatically convert images on save...)
if Image.getmodebase(im.mode) == "RGB":
imOut = im.convert("P")
rawmode = "P"
else:
imOut = im.convert("L")
rawmode = "L"
# header
for s in getheader(imOut, im.encoderinfo):
fp.write(s)
flags = 0
try:
interlace = im.encoderinfo["interlace"]
except:
# default is on (since we're writing uncompressed images)
interlace = 1
flags = flags | 64
# local image header
fp.write(
"," + o16(0) + o16(0) + o16(im.size[0]) + o16(im.size[1]) + chr(flags) + chr(8) # bounding box # size # flags
) # bits
imOut.encoderconfig = (8, interlace)
ImageFile._save(imOut, fp, [("gif", (0, 0) + im.size, 0, rawmode)])
fp.write("\0") # end of image data
fp.write(";") # end of file
try:
fp.flush()
except:
pass
def getdata(im, offset = (0, 0), **params):
"""Return a list of strings representing this image.
The first string is a local image header, the rest contains
encoded image data."""
class collector:
data = []
def write(self, data):
self.data.append(data)
im.load() # make sure raster data is available
fp = collector()
try:
im.encoderinfo = params
# local image header
fp.write("," +
o16(offset[0]) + # offset
o16(offset[1]) +
o16(im.size[0]) + # size
o16(im.size[1]) +
chr(0) + # flags
chr(8)) # bits
ImageFile._save(im, fp, [("gif", (0,0)+im.size, 0, RAWMODE[im.mode])])
fp.write("\0") # end of image data
finally:
del im.encoderinfo
return fp.data
def _save(im, fp, filename, check=0):
try:
type, rawmode = SAVE[im.mode]
except KeyError:
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)
if filename:
fp.write("Name: %s\r\n" % filename)
fp.write("Image size (x*y): %d*%d\r\n" % im.size)
fp.write("File size (no of images): %d\r\n" % frames)
if im.mode == "P":
fp.write("Lut: 1\r\n")
fp.write("\000" * (511-fp.tell()) + "\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))])
def _save(im, fp, filename):
if im.mode != "1":
raise IOError, "cannot write mode %s as MSP" % im.mode
# create MSP header
header = [0] * 16
header[0], header[1] = i16("Da"), i16("nM") # version 1
header[2], header[3] = im.size
header[4], header[5] = 1, 1
header[6], header[7] = 1, 1
header[8], header[9] = im.size
sum = 0
for h in header:
sum = sum ^ h
header[12] = sum # FIXME: is this the right field?
# header
for h in header:
fp.write(o16(h))
# image body
ImageFile._save(im, fp, [("raw", (0,0)+im.size, 32, ("1", 0, 1))])
def update(self):
self.images = []
self.images_ui.clear()
path = self.selecter.getPath()
files = []
files = os.listdir(path)
# print "update_path:" + path
if path != "/":
files.insert(0, "..")
for f in files:
# Create QCustomQWidget
full_path = os.path.join(self.selecter.getPath(), f)
# print full_path
myQCustomQWidget = ImageFile(full_path)
# Create QListWidgetItem
myQListWidgetItem = QtGui.QListWidgetItem(self.images_ui)
# Set size hint# self.update()
myQListWidgetItem.setSizeHint(myQCustomQWidget.sizeHint()) #
myQListWidgetItem.setData(0, QtCore.QVariant(myQCustomQWidget))
# Add QListWidgetItem into QListWidget# self.images_ui.itemClicked.connect(self.itemClicked)
self.images_ui.addItem(
myQListWidgetItem) # self.setShown(True)
self.images_ui.setItemWidget(
myQListWidgetItem, myQCustomQWidget) # self.show()
self.images.append(myQCustomQWidget)
def _save(im, fp, filename):
if im.mode != "1":
raise IOError, "cannot write mode %s as MSP" % im.mode
# create MSP header
header = [0] * 16
header[0], header[1] = i16("Da"), i16("nM") # version 1
header[2], header[3] = im.size
header[4], header[5] = 1, 1
header[6], header[7] = 1, 1
header[8], header[9] = im.size
sum = 0
for h in header:
sum = sum ^ h
header[12] = sum # FIXME: is this the right field?
# header
for h in header:
fp.write(o16(h))
# image body
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 32, ("1", 0, 1))])
def _save(im, fp, filename):
try:
rawmode = RAWMODE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as JPEG" % im.mode)
info = im.encoderinfo
dpi = info.get("dpi", (0, 0))
# get keyword arguments
im.encoderconfig = (
info.get("quality", 0),
# "progressive" is the official name, but older documentation
# says "progression"
# FIXME: issue a warning if the wrong form is used (post-1.1.5)
info.has_key("progressive") or info.has_key("progression"),
info.get("smooth", 0),
info.has_key("optimize"),
info.get("streamtype", 0),
dpi[0], dpi[1]
)
ImageFile._save(im, fp, [("jpeg", (0,0)+im.size, 0, rawmode)])
def _save(im, fp, filename, check=0):
try:
rawmode, bits, colormaptype, imagetype = SAVE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as TGA" % im.mode)
if check:
return check
if colormaptype:
colormapfirst, colormaplength, colormapentry = 0, 256, 24
else:
colormapfirst, colormaplength, colormapentry = 0, 0, 0
if im.mode == "RGBA":
flags = 8
else:
flags = 0
orientation = im.info.get("orientation", -1)
if orientation > 0:
flags = flags | 0x20
fp.write("\000" + chr(colormaptype) + chr(imagetype) + o16(colormapfirst) +
o16(colormaplength) + chr(colormapentry) + o16(0) + o16(0) +
o16(im.size[0]) + o16(im.size[1]) + chr(bits) + chr(flags))
if colormaptype:
fp.write(im.im.getpalette("RGB", "BGR"))
ImageFile._save(im, fp,
[("raw", (0, 0) + im.size, 0, (rawmode, 0, orientation))])
def _save(im, fp, filename):
try:
rawmode = RAWMODE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as JPEG" % im.mode)
info = im.encoderinfo
dpi = info.get("dpi", (0, 0))
# get keyword arguments
im.encoderconfig = (
info.get("quality", 0),
# "progressive" is the official name, but older documentation
# says "progression"
# FIXME: issue a warning if the wrong form is used (post-1.1.5)
info.has_key("progressive") or info.has_key("progression"),
info.get("smooth", 0),
info.has_key("optimize"),
info.get("streamtype", 0),
dpi[0],
dpi[1])
ImageFile._save(im, fp, [("jpeg", (0, 0) + im.size, 0, rawmode)])
def saveStack(imstack, filename):
hdr_stack = makeSpiderHeaderOverall(imstack)
if len(hdr_stack) < 256:
raise IOError, "Error creating Spider 2D stack header"
# write the SPIDER header
try:
fp = open(filename, 'wb')
except:
raise IOError, "Unable to open %s for writing" % filename
fp.writelines(hdr_stack)
rawmode = "F;32NF" #32-bit native floating point
ct = 0
for im in imstack:
ct += 1 # numbering of stacked images
if im.mode[0] != "F":
im = im.convert('F')
hdr = makeSpiderHeaderInStack(im, ct) # h[27]=ct
if len(hdr) < 256:
raise IOError, "Error creating Spider header"
fp.writelines(hdr)
#ims = im.tostring()
#fp.write(ims)
ImageFile._save(im, fp,
[("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))])
fp.close()
def _save(im, fp, filename, check=0):
try:
type, rawmode = SAVE[im.mode]
except KeyError:
raise ValueError("Cannot save {0} images as IM".format(im.mode))
try:
frames = im.encoderinfo["frames"]
except KeyError:
frames = 1
if check:
return check
data = []
data.append("Image type: {0} image\r\n".format(type))
if filename:
data.append("Name: {0}\r\n".format(filename))
data.append("Image size (x*y): {size[0]}*{size[1]}\r\n".format(size=im.size))
data.append("File size (no of images): {0}\r\n".format(frames))
if im.mode == "P":
data.append("Lut: 1\r\n")
fp.write(''.join(data).encode('latin_1', errors='replace'))
fp.write(b"\x00" * (511-fp.tell()) + b"\x1a")
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))])
def getdata(im, offset=(0, 0), **params):
"""Return a list of strings representing this image.
The first string is a local image header, the rest contains
encoded image data."""
class collector:
data = []
def write(self, data):
self.data.append(data)
im.load() # make sure raster data is available
fp = collector()
try:
im.encoderinfo = params
# local image header
fp.write("," + o16(offset[0]) + # offset
o16(offset[1]) + o16(im.size[0]) + # size
o16(im.size[1]) + chr(0) + # flags
chr(8)) # bits
ImageFile._save(im, fp,
[("gif", (0, 0) + im.size, 0, RAWMODE[im.mode])])
fp.write("\0") # end of image data
finally:
del im.encoderinfo
return fp.data
def _save(im, fp, filename, check=0):
try:
type, rawmode = SAVE[im.mode]
except KeyError:
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)
if filename:
fp.write("Name: %s\r\n" % filename)
fp.write("Image size (x*y): %d*%d\r\n" % im.size)
fp.write("File size (no of images): %d\r\n" % frames)
if im.mode == "P":
fp.write("Lut: 1\r\n")
fp.write("\000" * (511 - fp.tell()) + "\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))])
def _save(im, fp, filename):
if im.mode != "RGB":
raise IOError("cannot write mode %s as WEBP" % im.mode)
im.encoderconfig = (
im.encoderinfo.get("quality", 0),
)
ImageFile._save(im, fp, [("webp", (0, 0) + im.size, 0, (im.mode,))])
def CreateStereoBag(left_imgs, right_imgs, bagname):
'''Creates a bag file containing stereo image pairs'''
bag = rosbag.Bag(bagname, 'w')
try:
for i in range(len(left_imgs)):
print("Adding %s" % left_imgs[i])
fp_left = open(left_imgs[i], "r")
p_left = ImageFile.Parser()
while 1:
s = fp_left.read(1024)
if not s:
break
p_left.feed(s)
im_left = p_left.close()
fp_right = open(right_imgs[i], "r")
print("Adding %s" % right_imgs[i])
p_right = ImageFile.Parser()
while 1:
s = fp_right.read(1024)
if not s:
break
p_right.feed(s)
im_right = p_right.close()
Stamp = roslib.rostime.Time.from_sec(time.time())
Img_left = Image()
Img_left.header.stamp = Stamp
Img_left.width = im_left.size[0]
Img_left.height = im_left.size[1]
Img_left.encoding = "rgb8"
Img_left.header.frame_id = "camera/left"
Img_left_data = [
pix for pixdata in im_left.getdata() for pix in pixdata
]
Img_left.data = Img_left_data
Img_right = Image()
Img_right.header.stamp = Stamp
Img_right.width = im_right.size[0]
Img_right.height = im_right.size[1]
Img_right.encoding = "rgb8"
Img_right.header.frame_id = "camera/right"
Img_right_data = [
pix for pixdata in im_right.getdata() for pix in pixdata
]
Img_right.data = Img_right_data
bag.write('camera/left/image_raw', Img_left, Stamp)
bag.write('camera/right/image_raw', Img_right, Stamp)
finally:
bag.close()
def _save(im, fp, filename, check=0):
try:
version, bits, planes, rawmode = SAVE[im.mode]
except KeyError:
raise ValueError, "Cannot save %s images as PCX" % im.mode
if check:
return check
# bytes per plane
stride = (im.size[0] * bits + 7) / 8
# under windows, we could determine the current screen size with
# "Image.core.display_mode()[1]", but I think that's overkill...
screen = im.size
dpi = 100, 100
# PCX header
fp.write(
chr(10)
+ chr(version)
+ chr(1)
+ chr(bits)
+ o16(0)
+ o16(0)
+ o16(im.size[0] - 1)
+ o16(im.size[1] - 1)
+ o16(dpi[0])
+ o16(dpi[1])
+ chr(0) * 24
+ chr(255) * 24
+ chr(0)
+ chr(planes)
+ o16(stride)
+ o16(1)
+ o16(screen[0])
+ o16(screen[1])
+ chr(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(chr(12))
fp.write(im.im.getpalette("RGB", "RGB")) # 768 bytes
elif im.mode == "L":
# greyscale palette
fp.write(chr(12))
for i in range(256):
fp.write(chr(i) * 3)
def _save(im, fp, filename, eps=1):
"""EPS Writer for the Python Imaging Library."""
#
# make sure image data is available
im.load()
#
# determine postscript image mode
if im.mode == "L":
operator = (8, 1, "image")
elif im.mode == "RGB":
operator = (8, 3, "false 3 colorimage")
elif im.mode == "CMYK":
operator = (8, 4, "false 4 colorimage")
else:
raise ValueError("image mode is not supported")
if eps:
#
# write EPS header
fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
#fp.write("%%CreationDate: %s"...)
fp.write("%%BoundingBox: 0 0 {0[0]} {0[1]}\n".format(im.size).encode(
'latin_1', errors='replace'))
fp.write(b"%%Pages: 1\n")
fp.write(b"%%EndComments\n")
fp.write(b"%%Page: 1 1\n")
fp.write("%%ImageData: {0[0]} {0[1]}".format(im.size).encode('latin_1',
errors='replace'))
fp.write("{0[0]} {0[1]} 0 1 1 \"{0[2]}\"\n".format(operator).encode(
'latin_1', errors='replace'))
#
# image header
fp.write(b"gsave\n")
fp.write(b"10 dict begin\n")
fp.write("/buf {0} string def\n".format(im.size[0]*operator[1]).encode(
'latin_1', errors='replace'))
fp.write("{0[0]} {0[1]} scale\n".format(im.size).encode('latin_1',
errors='replace'))
fp.write("{0[0]} {0[1]} 8\n".format(im.size).encode('latin_1',
errors='replace')) # <= bits
fp.write("[{0[0]} 0 0 -{0[1]} 0 {0[1]}]\n".format(im.size).encode(
'latin_1', errors='replace'))
fp.write(b"{ currentfile buf readhexstring pop } bind\n")
fp.write("{0[2]}\n".format(operator).encode('latin_1', errors='replace'))
ImageFile._save(im, fp, [("eps", (0,0)+im.size, 0, None)])
fp.write(b"\n%%EndBinary\n")
fp.write(b"grestore end\n")
fp.flush()
def _save(im, fp, filename):
try:
rawmode = RAWMODE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as JPEG" % im.mode)
info = im.encoderinfo
dpi = info.get("dpi", (0, 0))
subsampling = info.get("subsampling", -1)
if subsampling == "4:4:4":
subsampling = 0
elif subsampling == "4:2:2":
subsampling = 1
elif subsampling == "4:1:1":
subsampling = 2
extra = ""
icc_profile = info.get("icc_profile")
if icc_profile:
ICC_OVERHEAD_LEN = 14
MAX_BYTES_IN_MARKER = 65533
MAX_DATA_BYTES_IN_MARKER = MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN
markers = []
while icc_profile:
markers.append(icc_profile[:MAX_DATA_BYTES_IN_MARKER])
icc_profile = icc_profile[MAX_DATA_BYTES_IN_MARKER:]
i = 1
for marker in markers:
size = struct.pack(">H", 2 + ICC_OVERHEAD_LEN + len(marker))
extra = extra + ("\xFF\xE2" + size + "ICC_PROFILE\0" + chr(i) + chr(len(markers)) + marker)
i = i + 1
# get keyword arguments
im.encoderconfig = (
info.get("quality", 0),
# "progressive" is the official name, but older documentation
# says "progression"
# FIXME: issue a warning if the wrong form is used (post-1.1.7)
info.has_key("progressive") or info.has_key("progression"),
info.get("smooth", 0),
info.has_key("optimize"),
info.get("streamtype", 0),
dpi[0], dpi[1],
subsampling,
extra,
)
ImageFile.MAXBLOCK = 10000000
ImageFile._save(im, fp, [("jpeg", (0,0)+im.size, 0, rawmode)])
def _save(im, fp, filename):
try:
rawmode = RAWMODE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as JPEG" % im.mode)
info = im.encoderinfo
dpi = info.get("dpi", (0, 0))
subsampling = info.get("subsampling", -1)
if subsampling == "4:4:4":
subsampling = 0
elif subsampling == "4:2:2":
subsampling = 1
elif subsampling == "4:1:1":
subsampling = 2
extra = ""
icc_profile = info.get("icc_profile")
if icc_profile:
ICC_OVERHEAD_LEN = 14
MAX_BYTES_IN_MARKER = 65533
MAX_DATA_BYTES_IN_MARKER = MAX_BYTES_IN_MARKER - ICC_OVERHEAD_LEN
markers = []
while icc_profile:
markers.append(icc_profile[:MAX_DATA_BYTES_IN_MARKER])
icc_profile = icc_profile[MAX_DATA_BYTES_IN_MARKER:]
i = 1
for marker in markers:
size = struct.pack(">H", 2 + ICC_OVERHEAD_LEN + len(marker))
extra = extra + ("\xFF\xE2" + size + "ICC_PROFILE\0" + chr(i) +
chr(len(markers)) + marker)
i = i + 1
# get keyword arguments
im.encoderconfig = (
info.get("quality", 0),
# "progressive" is the official name, but older documentation
# says "progression"
# FIXME: issue a warning if the wrong form is used (post-1.1.7)
info.has_key("progressive") or info.has_key("progression"),
info.get("smooth", 0),
info.has_key("optimize"),
info.get("streamtype", 0),
dpi[0],
dpi[1],
subsampling,
extra,
)
ImageFile._save(im, fp, [("jpeg", (0, 0) + im.size, 0, rawmode)])
def _save(im, fp, filename, eps=1):
"""EPS Writer for the Python Imaging Library."""
#
# make sure image data is available
im.load()
#
# determine postscript image mode
if im.mode == "L":
operator = (8, 1, "image")
elif im.mode == "RGB":
operator = (8, 3, "false 3 colorimage")
elif im.mode == "CMYK":
operator = (8, 4, "false 4 colorimage")
else:
raise ValueError("image mode is not supported")
if eps:
#
# write EPS header
fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
#fp.write(b"%%CreationDate: %s"...)
fp.write(
bytes("%%%%BoundingBox: 0 0 %d %d\n" % im.size, encoding='ascii'))
fp.write(b"%%Pages: 1\n")
fp.write(b"%%EndComments\n")
fp.write(b"%%Page: 1 1\n")
fp.write(bytes("%%ImageData: %d %d " % im.size, encoding='ascii'))
fp.write(bytes("%d %d 0 1 1 \"%s\"\n" % operator, encoding='ascii'))
#
# image header
fp.write(b"gsave\n")
fp.write(b"10 dict begin\n")
fp.write(
bytes("/buf %d string def\n" % (im.size[0] * operator[1]),
encoding='ascii'))
fp.write(bytes("%d %d scale\n" % im.size, encoding='ascii'))
fp.write(bytes("%d %d 8\n" % im.size, encoding='ascii')) # <= bits
fp.write(
bytes("[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1], im.size[1]),
encoding='ascii'))
fp.write(b"{ currentfile buf readhexstring pop } bind\n")
fp.write(bytes("%s\n" % operator[2], encoding='ascii'))
ImageFile._save(im, fp, [("eps", (0, 0) + im.size, 0, None)])
fp.write(b"\n%%%%EndBinary\n")
fp.write(b"grestore end\n")
fp.flush()
def _save(im, fp, filename, check=0):
try:
version, bits, planes, rawmode = SAVE[im.mode]
except KeyError:
raise ValueError("Cannot save %s images as WBMP" % im.mode)
if check:
return check
width, height = im.size
# Write header
fp.write (chr(0) + chr(0) + _tomb(width) + _tomb(height))
# Write data
ImageFile._save(im, fp, [("raw", (0,0) + im.size, 0, (rawmode, 0, 1))])
def _save(im, fp, filename, check=0):
try:
version, bits, planes, rawmode = SAVE[im.mode]
except KeyError:
raise ValueError("Cannot save %s images as WBMP" % im.mode)
if check:
return check
width, height = im.size
# Write header
fp.write(chr(0) + chr(0) + _tomb(width) + _tomb(height))
# Write data
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))])
def _save(im, fp, filename, eps=1):
"""EPS Writer for the Python Imaging Library."""
#
# make sure image data is available
im.load()
#
# determine postscript image mode
if im.mode == "L":
operator = (8, 1, "image")
elif im.mode == "RGB":
operator = (8, 3, "false 3 colorimage")
elif im.mode == "CMYK":
operator = (8, 4, "false 4 colorimage")
else:
raise ValueError("image mode is not supported")
if eps:
#
# write EPS header
fp.write(b"%!PS-Adobe-3.0 EPSF-3.0\n")
fp.write(b"%%Creator: PIL 0.1 EpsEncode\n")
#fp.write(b"%%CreationDate: %s"...)
fp.write(bytes("%%%%BoundingBox: 0 0 %d %d\n" % im.size,
encoding='ascii'))
fp.write(b"%%Pages: 1\n")
fp.write(b"%%EndComments\n")
fp.write(b"%%Page: 1 1\n")
fp.write(bytes("%%ImageData: %d %d " % im.size, encoding='ascii'))
fp.write(bytes("%d %d 0 1 1 \"%s\"\n" % operator, encoding='ascii'))
#
# image header
fp.write(b"gsave\n")
fp.write(b"10 dict begin\n")
fp.write(bytes("/buf %d string def\n" % (im.size[0] * operator[1]),
encoding='ascii'))
fp.write(bytes("%d %d scale\n" % im.size, encoding='ascii'))
fp.write(bytes("%d %d 8\n" % im.size, encoding='ascii')) # <= bits
fp.write(bytes("[%d 0 0 -%d 0 %d]\n" % (im.size[0], im.size[1],
im.size[1]), encoding='ascii'))
fp.write(b"{ currentfile buf readhexstring pop } bind\n")
fp.write(bytes("%s\n" % operator[2], encoding='ascii'))
ImageFile._save(im, fp, [("eps", (0,0)+im.size, 0, None)])
fp.write(b"\n%%%%EndBinary\n")
fp.write(b"grestore end\n")
fp.flush()
def _save(im, fp, filename):
if im.mode == "1":
rawmode, head = "1;I", "P4"
elif im.mode == "L":
rawmode, head = "L", "P5"
elif im.mode == "RGB":
rawmode, head = "RGB", "P6"
elif im.mode == "RGBA":
rawmode, head = "RGB", "P6"
else:
raise IOError, "cannot write mode %s as PPM" % im.mode
fp.write(head + "\n%d %d\n" % im.size)
if head != "P4":
fp.write("255\n")
ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))])
def _save(im, fp, filename):
if im.mode == "1":
rawmode, head = "1;I", "P4"
elif im.mode == "L":
rawmode, head = "L", "P5"
elif im.mode == "RGB":
rawmode, head = "RGB", "P6"
elif im.mode == "RGBA":
rawmode, head = "RGB", "P6"
else:
raise IOError, "cannot write mode %s as PPM" % im.mode
fp.write(head + "\n%d %d\n" % im.size)
if head != "P4":
fp.write("255\n")
ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, 1))])
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 + bytes("\n%d %d\n" % im.size, encoding='ascii'))
if head != b"P4":
fp.write(b"255\n")
ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, 1))])
def _fetch_image_size(url, referer):
"""Return the size of an image by URL downloading as little as possible."""
request = _initialize_request(url, referer)
if not request:
return None
parser = ImageFile.Parser()
response = None
try:
response = urllib2.urlopen(request)
while True:
chunk = response.read(1024)
if not chunk:
break
parser.feed(chunk)
if parser.image:
return parser.image.size
except urllib2.URLError:
return None
finally:
if response:
response.close()
def _save(im, fp, filename):
if im.mode == "1":
rawmode, head = "1;I", "P4"
elif im.mode == "L":
rawmode, head = "L", "P5"
elif im.mode == "RGB":
rawmode, head = "RGB", "P6"
elif im.mode == "RGBA":
rawmode, head = "RGB", "P6"
else:
raise IOError("cannot write mode {0} as PPM".format(im.mode))
fp.write(head + "\n{0} {1}\n".format(*im.size).encode('latin_1',
errors='replace'))
if head != "P4":
fp.write(b"255\n")
ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, 1))])
def recog(data, threshold=140):
p = ImageFile.Parser()
p.feed(data)
im = p.close()
imgry = im.convert('L')
out = imgry.point(lambda i: 0 if i < threshold else 255)
return image_to_string(out)
def getimagesize(url):
"""
Attempts to determine an image's width and height, and returns a string
suitable for use in an <img> tag, or None in case of failure.
Requires that PIL is installed.
>>> getimagesize("http://www.google.com/intl/en_ALL/images/logo.gif")
... #doctest: +ELLIPSIS, +SKIP
'width="..." height="..."'
"""
try:
import ImageFile
import urllib2
except ImportError:
return None
try:
p = ImageFile.Parser()
f = urllib2.urlopen(url)
while True:
s = f.read(1024)
if not s:
break
p.feed(s)
if p.image:
return 'width="%i" height="%i"' % p.image.size
except (IOError, ValueError):
return None
def analyse_png(self, png_name):
f = self.get_data(png_name)
buf = f.read()
f.close()
p = ImageFile.Parser()
p.feed(buf)
im = p.close()
self.total_pixels += im.size[0] * im.size[1]
if png_name.endswith('.jpg'):
notice('File %s is already compressed' % png_name)
return False
if len(buf) < self.size_threshold:
notice('File %s does not meet size threshold (size is %d)' %
(png_name, len(buf)))
return False
if self.force_regex.match(png_name):
warning('File %s will be forced' % png_name)
elif self.has_transparency(im):
notice('File %s has transparent pixels' % png_name)
if len(buf) >= self.size_warning_threshold:
warning('Transparent image is quite large: %s (%d bytes)' %
(png_name, len(buf)))
return False
ss = StringIO.StringIO()
try:
im.save(ss, 'JPEG', quality=self.compression_level)
except IOError, ex:
warning('Unable to convert %s to JPEG: %s' % (png_name, ex))
return False
def SOF(self, marker):
#
# Start of frame marker. Defines the size and mode of the
# image. JPEG is colour blind, so we use some simple
# heuristics to map the number of layers to an appropriate
# mode. Note that this could be made a bit brighter, by
# looking for JFIF and Adobe APP markers.
n = i16(self.fp.read(2))-2
s = ImageFile._safe_read(self.fp, n)
self.size = i16(s[3:]), i16(s[1:])
self.bits = ord(s[0])
if self.bits != 8:
raise SyntaxError("cannot handle %d-bit layers" % self.bits)
self.layers = ord(s[5])
if self.layers == 1:
self.mode = "L"
elif self.layers == 3:
self.mode = "RGB"
elif self.layers == 4:
self.mode = "CMYK"
else:
raise SyntaxError("cannot handle %d-layer images" % self.layers)
if marker in [0xFFC2, 0xFFC6, 0xFFCA, 0xFFCE]:
self.info["progression"] = 1
for i in range(6, len(s), 3):
t = s[i:i+3]
# 4-tuples: id, vsamp, hsamp, qtable
self.layer.append((t[0], ord(t[1])/16, ord(t[1])&15, ord(t[2])))
def get_picture(self):
if self.stream_file is None:
return None
image_parser = ImageFile.Parser()
self.stream_file.readline() # skip boundary
self.stream_file.readline() # Content-type
p = self.stream_file.readline() # Content-Length
try:
cl = int(p[p.find(' ') + 1:-2])
except ValueError:
self.stream_file = None
return None
self.stream_file.readline() # Empty
image_parser.feed(self.stream_file.read(cl))
image = image_parser.close()
surface = pygame.image.fromstring(
image.tostring(),
image.size,
image.mode)
self.stream_file.readline() # skip eol
self.stream_file.readline() # skip eol
return surface
def CreateBag(imgs,bagname):
'''Creates a bag file with camera images'''
bag =rosbag.Bag(bagname, 'w')
try:
for i in range(len(imgs)):
print("Adding %s" % imgs[i])
fp = open( imgs[i], "r" )
p = ImageFile.Parser()
while 1:
s = fp.read(1024)
if not s:
break
p.feed(s)
im = p.close()
if im.mode != "RGB":
im=im.convert("RGB")
Stamp = rospy.rostime.Time.from_sec(time.time())
Img = Image()
Img.header.stamp = Stamp
Img.width = im.size[0]
Img.height = im.size[1]
Img.encoding = "rgb8"
Img.step = Img.width *3;
Img.header.frame_id = "camera"
Img_data = [pix for pixdata in im.getdata() for pix in pixdata]
Img.data = Img_data
bag.write('/camera/image', Img, Stamp)
finally:
bag.close()
def CreateMonoBag(imgs, bagname):
'''Creates a bag file with camera images'''
bag = rosbag.Bag(bagname, 'w')
try:
for i in range(len(imgs)):
print("Adding %s" % imgs[i])
fp = open(imgs[i], "r")
p = ImageFile.Parser()
while 1:
s = fp.read(1024)
if not s:
break
p.feed(s)
im = p.close()
#Stamp = rospy.rostime.Time.from_sec(time.time())
Stamp = rospy.Time.from_sec(time.time())
Img = Image()
Img.header.stamp = Stamp
Img.width = im.size[0]
Img.height = im.size[1]
#Img.encoding = "rgb8"
Img.encoding = "mono8"
Img.header.frame_id = "camera"
Img_data = [pix for pixdata in im.getdata() for pix in pixdata]
#Img_data = [pix for pixdata in [im.getdata()] for pix in pixdata]
Img.data = Img_data
#Change "rgb8" encoding to "mono8", and "[pix for pixdata in im.getdata() for pix in pixdata]" to "[pix for pixdata in [im.getdata()] for pix in pixdata]"
bag.write('camera/image_raw', Img, Stamp)
finally:
bag.close()
def siteconfig(request):
if request.method == 'GET':
return render_to_response('admin/siteconfig.html')
if request.method == 'POST':
sitename = request.POST.get('sitename')
keywords = request.POST.get('keywords')
descriptions = request.POST.get('descriptions')
copyrightinfo = request.POST.get('copyrightinfo')
form = PictureForm(request.POST, request.FILES)
if form.is_valid():
if 'login' and 'banner' in request.FILES:
login = request.FILES["login"]
banner = request.FILES["banner"]
else:
login = None
banner = None
parser = ImageFile.Parser()
for chunk in login.chunks() and banner.chunks():
parser.feed(chunk)
site = Site()
site.sitename = sitename
site.keywords = keywords
site.descriptions = descriptions
site.login = login
site.banner = banner
site.copyrightinfo = copyrightinfo
site.save()
return render_to_response('admin/siteconfig.html')
def SOF(self, marker):
#
# Start of frame marker. Defines the size and mode of the
# image. JPEG is colour blind, so we use some simple
# heuristics to map the number of layers to an appropriate
# mode. Note that this could be made a bit brighter, by
# looking for JFIF and Adobe APP markers.
n = i16(self.fp.read(2)) - 2
s = ImageFile._safe_read(self.fp, n)
self.size = i16(s[3:]), i16(s[1:])
self.bits = ord(s[0])
if self.bits != 8:
raise SyntaxError("cannot handle %d-bit layers" % self.bits)
self.layers = ord(s[5])
if self.layers == 1:
self.mode = "L"
elif self.layers == 3:
self.mode = "RGB"
elif self.layers == 4:
self.mode = "CMYK"
else:
raise SyntaxError("cannot handle %d-layer images" % self.layers)
if marker in [0xFFC2, 0xFFC6, 0xFFCA, 0xFFCE]:
self.info["progression"] = 1
for i in range(6, len(s), 3):
t = s[i:i + 3]
# 4-tuples: id, vsamp, hsamp, qtable
self.layer.append((t[0], ord(t[1]) / 16, ord(t[1]) & 15, ord(t[2])))
def chunk_PLTE(self, pos, len):
# palette
s = ImageFile._safe_read(self.fp, len)
if self.im_mode == "P":
self.im_palette = "RGB", s
return s
def chunk_PLTE(self, pos, len):
# palette
s = ImageFile._safe_read(self.fp, len)
if self.im_mode == "P":
self.im_palette = "RGB", s
return s
def _save(im, fp, filename, check=0):
try:
rawmode, bits, colors = SAVE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as BMP" % im.mode)
if check:
return check
stride = ((im.size[0] * bits + 7) / 8 + 3) & (~3)
header = 40 # or 64 for OS/2 version 2
offset = 14 + header + colors * 4
image = stride * im.size[1]
# bitmap header
fp.write("BM" + # file type (magic)
o32(offset + image) + # file size
o32(0) + # reserved
o32(offset)) # image data offset
# bitmap info header
fp.write(
o32(header) + # info header size
o32(im.size[0]) + # width
o32(im.size[1]) + # height
o16(1) + # planes
o16(bits) + # depth
o32(0) + # compression (0=uncompressed)
o32(image) + # size of bitmap
o32(1) + o32(1) + # resolution
o32(colors) + # colors used
o32(colors)) # colors important
fp.write("\000" * (header - 40)) # padding (for OS/2 format)
if im.mode == "1":
for i in (0, 255):
fp.write(chr(i) * 4)
elif im.mode == "L":
for i in range(256):
fp.write(chr(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))])
def _save(im, fp, filename, check=0):
try:
rawmode, bits, colors = SAVE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as BMP" % im.mode)
if check:
return check
stride = ((im.size[0] * bits + 7) / 8 + 3) & (~3)
header = 40 # or 64 for OS/2 version 2
offset = 14 + header + colors * 4
image = stride * im.size[1]
# bitmap header
fp.write(
"BM" + o32(offset + image) + o32(0) + o32(offset) # file type (magic) # file size # reserved
) # image data offset
# bitmap info header
fp.write(
o32(header)
+ o32(im.size[0]) # info header size
+ o32(im.size[1]) # width
+ o16(1) # height
+ o16(bits) # planes
+ o32(0) # depth
+ o32(image) # compression (0=uncompressed)
+ o32(1) # size of bitmap
+ o32(1)
+ o32(colors) # resolution
+ o32(colors) # colors used
) # colors important
fp.write("\000" * (header - 40)) # padding (for OS/2 format)
if im.mode == "1":
for i in (0, 255):
fp.write(chr(i) * 4)
elif im.mode == "L":
for i in range(256):
fp.write(chr(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))])
def _save(im, fp, filename):
try:
rawmode = RAWMODE[im.mode]
except KeyError:
raise IOError, "cannot write mode %s as JPEG" % im.mode
dpi = _fetch(im.encoderinfo, "dpi", (0, 0))
# get keyword arguments
im.encoderconfig = (_fetch(im.encoderinfo, "quality", 0),
im.encoderinfo.has_key("progressive"),
_fetch(im.encoderinfo, "smooth", 0),
im.encoderinfo.has_key("optimize"),
_fetch(im.encoderinfo, "streamtype", 0),
dpi[0], dpi[1])
ImageFile._save(im, fp, [("jpeg", (0,0)+im.size, 0, rawmode)])
def COM(self, marker):
#
# Comment marker. Store these in the APP dictionary.
n = i16(self.fp.read(2))-2
s = ImageFile._safe_read(self.fp, n)
self.app["COM"] = s # compatibility
self.applist.append(("COM", s))
def LoadCompressed(data):
JpegHeaderSize = ReadUInt32(data, _BLP_HEADER_SIZE)
Offset, Size = MipMap(data, 0)
parser = ImageFile.Parser()
parser.feed(data[_BLP_HEADER_SIZE+4:_BLP_HEADER_SIZE+4+JpegHeaderSize])
parser.feed(data[Offset:Offset+Size])
img = parser.close().convert('RGB')
r, g, b = img.split()
return Image.merge("RGB", (b, g, r))
def _save(im, fp, filename, check=0):
# check if im.mode is compatible with MRC (see Bmp...)
if check:
return check
header = MrcHeader()
header['width'] = im.size[0]
header['height'] = im.size[1]
header['depth'] = 1
header['mode'] = pilmode_mrcmode[im.mode]
header.tofile(fp)
rawmode = mrcmode_rawmode[header['mode']]
tile = [("raw", (0, 0) + im.size, header.headerlen, (rawmode, 0, 1))]
print 'savetile:', tile
ImageFile._save(im, fp, tile)
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])
fp.write("#define im_height %d\n" % im.size[1])
hotspot = im.encoderinfo.get("hotspot")
if hotspot:
fp.write("#define im_x_hot %d\n" % hotspot[0])
fp.write("#define im_y_hot %d\n" % hotspot[1])
fp.write("static char im_bits[] = {\n")
ImageFile._save(im, fp, [("xbm", (0,0)+im.size, 0, None)])
fp.write("};\n")
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])
fp.write("#define im_height %d\n" % im.size[1])
hotspot = im.encoderinfo.get("hotspot")
if hotspot:
fp.write("#define im_x_hot %d\n" % hotspot[0])
fp.write("#define im_y_hot %d\n" % hotspot[1])
fp.write("static char im_bits[] = {\n")
ImageFile._save(im, fp, [("xbm", (0, 0) + im.size, 0, None)])
fp.write("};\n")
def _save(im, fp, filename, check=0):
# check if im.mode is compatible with MRC (see Bmp...)
if check:
return check
header = MrcHeader()
header['width'] = im.size[0]
header['height'] = im.size[1]
header['depth'] = 1
header['mode'] = pilmode_mrcmode[im.mode]
header.tofile(fp)
rawmode = mrcmode_rawmode[header['mode']]
tile = [("raw", (0,0)+im.size, header.headerlen, (rawmode, 0, 1))]
print 'savetile:', tile
ImageFile._save(im, fp, tile)
def fetchTile(server, z, x, y):
url = '%s/ctile?style=7&v=1&scale=1&size=1' % server
url += '&md=backgroundMapnik2&z=%d&x=%d&y=%d' % (z, x, y)
logging.info('Fetching tile at: %s' % url)
tile = urllib2.urlopen(url)
parser = ImageFile.Parser()
parser.feed(tile.read())
im = parser.close()
return im
def COM(self, marker):
#
# Comment marker. Store these in the APP dictionary.
n = i16(self.fp.read(2)) - 2
s = ImageFile._safe_read(self.fp, n)
self.app["COM"] = s # compatibility
self.applist.append(("COM", s))
def APP(self, marker):
#
# Application marker. Store these in the APP dictionary.
# Also look for well-known application markers.
n = i16(self.fp.read(2))-2
s = ImageFile._safe_read(self.fp, n)
app = "APP%d" % (marker&15)
self.app[app] = s # compatibility
self.applist.append((app, s))
if marker == 0xFFE0 and s[:4] == "JFIF":
# extract JFIF information
self.info["jfif"] = version = i16(s, 5) # version
self.info["jfif_version"] = divmod(version, 256)
# extract JFIF properties
try:
jfif_unit = ord(s[7])
jfif_density = i16(s, 8), i16(s, 10)
except:
pass
else:
if jfif_unit == 1:
self.info["dpi"] = jfif_density
self.info["jfif_unit"] = jfif_unit
self.info["jfif_density"] = jfif_density
elif marker == 0xFFE1 and s[:5] == "Exif\0":
# extract Exif information (incomplete)
self.info["exif"] = s # FIXME: value will change
elif marker == 0xFFE2 and s[:5] == "FPXR\0":
# extract FlashPix information (incomplete)
self.info["flashpix"] = s # FIXME: value will change
elif marker == 0xFFE2 and s[:12] == "ICC_PROFILE\0":
# Since an ICC profile can be larger than the maximum size of
# a JPEG marker (64K), we need provisions to split it into
# multiple markers. The format defined by the ICC specifies
# one or more APP2 markers containing the following data:
# Identifying string ASCII "ICC_PROFILE\0" (12 bytes)
# Marker sequence number 1, 2, etc (1 byte)
# Number of markers Total of APP2's used (1 byte)
# Profile data (remainder of APP2 data)
# Decoders should use the marker sequence numbers to
# reassemble the profile, rather than assuming that the APP2
# markers appear in the correct sequence.
self.icclist.append(s)
elif marker == 0xFFEE and s[:5] == "Adobe":
self.info["adobe"] = i16(s, 5)
# extract Adobe custom properties
try:
adobe_transform = ord(s[1])
except:
pass
else:
self.info["adobe_transform"] = adobe_transform
def APP(self, marker):
#
# Application marker. Store these in the APP dictionary.
# Also look for well-known application markers.
n = i16(self.fp.read(2)) - 2
s = ImageFile._safe_read(self.fp, n)
app = "APP%d" % (marker & 15)
self.app[app] = s # compatibility
self.applist.append((app, s))
if marker == 0xFFE0 and s[:4] == "JFIF":
# extract JFIF information
self.info["jfif"] = version = i16(s, 5) # version
self.info["jfif_version"] = divmod(version, 256)
# extract JFIF properties
try:
jfif_unit = ord(s[7])
jfif_density = i16(s, 8), i16(s, 10)
except:
pass
else:
if jfif_unit == 1:
self.info["dpi"] = jfif_density
self.info["jfif_unit"] = jfif_unit
self.info["jfif_density"] = jfif_density
elif marker == 0xFFE1 and s[:5] == "Exif\0":
# extract Exif information (incomplete)
self.info["exif"] = s # FIXME: value will change
elif marker == 0xFFE2 and s[:5] == "FPXR\0":
# extract FlashPix information (incomplete)
self.info["flashpix"] = s # FIXME: value will change
elif marker == 0xFFE2 and s[:12] == "ICC_PROFILE\0":
# Since an ICC profile can be larger than the maximum size of
# a JPEG marker (64K), we need provisions to split it into
# multiple markers. The format defined by the ICC specifies
# one or more APP2 markers containing the following data:
# Identifying string ASCII "ICC_PROFILE\0" (12 bytes)
# Marker sequence number 1, 2, etc (1 byte)
# Number of markers Total of APP2's used (1 byte)
# Profile data (remainder of APP2 data)
# Decoders should use the marker sequence numbers to
# reassemble the profile, rather than assuming that the APP2
# markers appear in the correct sequence.
self.icclist.append(s)
elif marker == 0xFFEE and s[:5] == "Adobe":
self.info["adobe"] = i16(s, 5)
# extract Adobe custom properties
try:
adobe_transform = ord(s[1])
except:
pass
else:
self.info["adobe_transform"] = adobe_transform
def _save(im, fp, filename):
if im.mode[0] != "F":
im = im.convert('F')
hdr = makeSpiderHeader(im)
if len(hdr) < 256:
raise IOError, "Error creating Spider header"
# write the SPIDER header
try:
fp = open(filename, 'wb')
except:
raise IOError, "Unable to open %s for writing" % filename
fp.writelines(hdr)
rawmode = "F;32NF" #32-bit native floating point
ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode,0,1))])
fp.close()
def load(self, fp):
# load tag dictionary
self.reset()
i16 = self.i16
i32 = self.i32
for i in range(i16(fp.read(2))):
ifd = fp.read(12)
tag, typ = i16(ifd), i16(ifd, 2)
if Image.DEBUG:
import TiffTags
tagname = TiffTags.TAGS.get(tag, "unknown")
typname = TiffTags.TYPES.get(typ, "unknown")
print "tag: %s (%d)" % (tagname, tag),
print "- type: %s (%d)" % (typname, typ),
try:
dispatch = self.load_dispatch[typ]
except KeyError:
if Image.DEBUG:
print "- unsupported type", typ
continue # ignore unsupported type
size, handler = dispatch
size = size * i32(ifd, 4)
# Get and expand tag value
if size > 4:
here = fp.tell()
fp.seek(i32(ifd, 8))
data = ImageFile._safe_read(fp, size)
fp.seek(here)
else:
data = ifd[8 : 8 + size]
if len(data) != size:
raise IOError, "not enough data"
self.tagdata[tag] = typ, data
self.tagtype[tag] = typ
if Image.DEBUG:
if tag in (COLORMAP, IPTC_NAA_CHUNK, PHOTOSHOP_CHUNK, ICCPROFILE, XMP):
print "- value: <table: %d bytes>" % size
else:
print "- value:", self[tag]
self.next = i32(fp.read(4))
def chunk_zTXt(self, pos, len):
# compressed text
s = ImageFile._safe_read(self.fp, len)
k, v = string.split(s, "\0", 1)
comp_method = ord(v[0])
if comp_method != 0:
raise SyntaxError("Unknown compression method %s in zTXt chunk" % comp_method)
import zlib
self.im_info[k] = self.im_text[k] = zlib.decompress(v[1:])
return s
def chunk_tRNS(self, pos, len):
# transparency
s = ImageFile._safe_read(self.fp, len)
if self.im_mode == "P":
i = string.find(s, chr(0))
if i >= 0:
self.im_info["transparency"] = i
elif self.im_mode == "L":
self.im_info["transparency"] = i16(s)
return s
def chunk_tEXt(self, pos, len):
# text
s = ImageFile._safe_read(self.fp, len)
try:
k, v = string.split(s, "\0", 1)
except ValueError:
k = s; v = "" # fallback for broken tEXt tags
if k:
self.im_info[k] = self.im_text[k] = v
return s
def _save(im, fp, filename, check=0):
try:
rawmode, bits, colormaptype, imagetype = SAVE[im.mode]
except KeyError:
raise IOError("cannot write mode %s as TGA" % im.mode)
if check:
return check
if colormaptype:
colormapfirst, colormaplength, colormapentry = 0, 256, 24
else:
colormapfirst, colormaplength, colormapentry = 0, 0, 0
if im.mode == "RGBA":
flags = 8
else:
flags = 0
orientation = im.info.get("orientation", -1)
if orientation > 0:
flags = flags | 0x20
fp.write("\000" +
chr(colormaptype) +
chr(imagetype) +
o16(colormapfirst) +
o16(colormaplength) +
chr(colormapentry) +
o16(0) +
o16(0) +
o16(im.size[0]) +
o16(im.size[1]) +
chr(bits) +
chr(flags))
if colormaptype:
fp.write(im.im.getpalette("RGB", "BGR"))
ImageFile._save(im, fp, [("raw", (0,0)+im.size, 0, (rawmode, 0, orientation))])
def chunk_pHYs(self, pos, len):
# pixels per unit
s = ImageFile._safe_read(self.fp, len)
px, py = i32(s), i32(s[4:])
unit = ord(s[8])
if unit == 1: # meter
dpi = int(px * 0.0254 + 0.5), int(py * 0.0254 + 0.5)
self.im_info["dpi"] = dpi
elif unit == 0:
self.im_info["aspect"] = px, py
return s