def testQuality(self):
img1 = scaleImage(CMYK, 84, 103)[0]
img2 = scaleImage(CMYK, 84, 103, quality=50)[0]
img3 = scaleImage(CMYK, 84, 103, quality=20)[0]
self.assertNotEqual(img1, img2)
self.assertNotEqual(img1, img3)
self.failUnless(len(img1) > len(img2) > len(img3))
def testDeprecations(self):
import guillotina.contrib.image.scale
# clear warnings registry, so the test actually sees the warning
guillotina.contrib.image.scale.__warningregistry__.clear()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
scaleImage(PNG, 16, 16, direction="keep")
self.assertEqual(len(w), 1)
self.assertIs(w[0].category, DeprecationWarning)
self.assertIn("the 'direction' option is deprecated",
str(w[0].message))
def testAlphaForcesPNG(self):
# first image without alpha
src = PIL.Image.new("RGBA", (256, 256), (255, 255, 255, 255))
for y in range(0, 256):
for x in range(0, 256):
src.putpixel((x, y), (x, y, 0, 255))
result = BytesIO()
src.save(result, "TIFF")
self.assertEqual(scaleImage(result, 84, 103, "contain")[1], "JPEG")
# now with alpha
src = PIL.Image.new("RGBA", (256, 256), (255, 255, 255, 128))
result = BytesIO()
for y in range(0, 256):
for x in range(0, 256):
src.putpixel((x, y), (x, y, 0, x))
src.save(result, "TIFF")
self.assertEqual(scaleImage(result, 84, 103, "contain")[1], "PNG")
def testAutomaticGreyscale(self):
src = PIL.Image.new("RGB", (256, 256), (255, 255, 255))
draw = PIL.ImageDraw.Draw(src)
for i in range(0, 256):
draw.line(((0, i), (256, i)), fill=(i, i, i))
result = BytesIO()
src.save(result, "JPEG")
(imagedata, format, size) = scaleImage(result, 200, None, "contain")
image = PIL.Image.open(BytesIO(imagedata))
self.assertEqual(max(image.size), 200)
self.assertEqual(image.mode, "L")
self.assertEqual(image.format, "JPEG")
def testAutomaticPalette(self):
# get a JPEG with more than 256 colors
jpeg = PIL.Image.open(BytesIO(PROFILE))
self.assertEqual(jpeg.mode, "RGB")
self.assertEqual(jpeg.format, "JPEG")
self.assertIsNone(jpeg.getcolors(maxcolors=256))
# convert to PNG
dst = BytesIO()
jpeg.save(dst, "PNG")
dst.seek(0)
png = PIL.Image.open(dst)
self.assertEqual(png.mode, "RGB")
self.assertEqual(png.format, "PNG")
self.assertIsNone(png.getcolors(maxcolors=256))
# scale it to a size where we get less than 256 colors
(imagedata, format, size) = scaleImage(dst.getvalue(), 24, None,
"contain")
image = PIL.Image.open(BytesIO(imagedata))
# we should now have an image in palette mode
self.assertEqual(image.mode, "P")
self.assertEqual(image.format, "PNG")
def testNewSizeReturned(self):
(imagedata, format, size) = scaleImage(PNG, 42, 51, "contain")
input = BytesIO(imagedata)
image = PIL.Image.open(input)
self.assertEqual(image.size, size)
def testScaledImageKeepPNG(self):
self.assertEqual(scaleImage(PNG, 84, 103, "contain")[1], "PNG")
def testCropPreTallScaleUnspecifiedWidth(self):
image = scaleImage(PNG, None, 400, "contain")
self.assertEqual(image[2], (326, 400))
def testResultBuffer(self):
img1 = scaleImage(PNG, 84, 103)[0]
result = BytesIO()
img2 = scaleImage(PNG, 84, 103, result=result)[0]
self.assertEqual(result, img2) # the return value _is_ the buffer
self.assertEqual(result.getvalue(), img1) # but with the same value
def testRestrictHeightOnlyDownScaleZero(self):
self.assertEqual(scaleImage(PNG, 0, 51, "contain")[2], (42, 51))
def testCropPreWideScaleUnspecifiedHeight(self):
image = scaleImage(PNG, 400, None, "contain")
self.assertEqual(image[2], (400, 490))
def testScaledCMYKIsRGB(self):
(imagedata, format, size) = scaleImage(CMYK, 42, 51, "contain")
input = BytesIO(imagedata)
image = PIL.Image.open(input)
self.assertEqual(image.mode, "RGB")
def testScaledImageIsJpeg(self):
self.assertEqual(scaleImage(TIFF, 84, 103, "contain")[1], "JPEG")
def testNoStretchingUpScale(self):
self.assertEqual(scaleImage(PNG, 200, 103, "cover")[2], (84, 103))
def testRestrictWidthOnlyUpScaleZero(self):
self.assertEqual(scaleImage(PNG, 42, 0, "cover")[2], (42, 52))
def testHalfSizeUpScale(self):
self.assertEqual(scaleImage(PNG, 42, 51, "cover")[2], (42, 51))
def testDoubleSizeUpScale(self):
self.assertEqual(scaleImage(PNG, 168, 206, "cover")[2], (168, 206))
def testSameSizeUpScale(self):
self.assertEqual(scaleImage(PNG, 84, 103, "cover")[2], (84, 103))
def testCropPreWideScale(self):
image = scaleImage(PNG, 400, 100, "contain")
self.assertEqual(image[2], (400, 100))
def testScaledPreservesProfile(self):
(imagedata, format, size) = scaleImage(PROFILE, 42, 51, "contain")
input = BytesIO(imagedata)
image = PIL.Image.open(input)
self.assertIsNotNone(image.info.get("icc_profile"))
def testScaledImageKeepGIFto(self):
self.assertEqual(scaleImage(GIF, 84, 103, "contain")[1], "PNG")
def testCropPreTallScale(self):
image = scaleImage(PNG, 100, 400, "contain")
self.assertEqual(image[2], (100, 400))
def testRestrictHeightOnlyUpScaleZero(self):
self.assertEqual(scaleImage(PNG, 0, 51, "cover")[2], (42, 51))
def testRestrictWidthOnlyDownScaleZero(self):
self.assertEqual(scaleImage(PNG, 42, 0, "contain")[2], (42, 52))
def testScaledPngImageIsPng(self):
self.assertEqual(scaleImage(PNG, 84, 103, "contain")[1], "PNG")
def testKeepAspectRatio(self):
self.assertEqual(scaleImage(PNG, 80, 80, "scale")[2], (65, 80))
def testScaleWithFewColorsStaysColored(self):
(imagedata, format, size) = scaleImage(PROFILE, 16, None, "contain")
image = PIL.Image.open(BytesIO(imagedata))
self.assertEqual(max(image.size), 16)
self.assertEqual(image.mode, "RGB")
self.assertEqual(image.format, "JPEG")
def testThumbnailHeightNone(self):
self.assertEqual(scaleImage(PNG, 42, None, "scale")[2], (42, 51))
def testThumbnailWidthNone(self):
self.assertEqual(scaleImage(PNG, None, 51, "scale")[2], (41, 51))
def testHugeScale(self):
# the image will be cropped, but not scaled
self.assertEqual(scaleImage(PNG, 400, 99999, "contain")[2], (2, 103))
