from imagekit.lib import Image from . import crop import warnings from . import Anchor class BasicResize(object): """ Resizes an image to the specified width and height. """ def __init__(self, width, height): """ :param width: The target width, in pixels. :param height: The target height, in pixels. """ self.width = width self.height = height def process(self, img): return img.resize((self.width, self.height), Image.ANTIALIAS) class Cover(object): """ Resizes the image to the smallest possible size that will entirely cover the provided dimensions. You probably won't be using this processor directly, but it's used internally by ``Fill`` and ``SmartFill``. """ def __init__(self, width, height): """ :param width: The target width, in pixels. :param height: The target height, in pixels. """ self.width, self.height = width, height def process(self, img): original_width, original_height = img.size ratio = max(float(self.width) / original_width, float(self.height) / original_height) new_width, new_height = (int(original_width * ratio), int(original_height * ratio)) return BasicResize(new_width, new_height).process(img) class Fill(object): """ Resizes an image, cropping it to the exact specified width and height. """ def __init__(self, width=None, height=None, anchor=None): """ :param width: The target width, in pixels. :param height: The target height, in pixels. :param anchor: Specifies which part of the image should be retained when cropping. """ self.width = width self.height = height self.anchor = anchor def process(self, img): img = Cover(self.width, self.height).process(img) return crop.Crop(self.width, self.height, anchor=self.anchor).process(img) class SmartFill(object): """ The ``SmartFill`` processor is identical to ``Fill``, except that it uses entropy to crop the image instead of a user-specified anchor point. Internally, it simply runs the ``resize.Cover`` and ``crop.SmartCrop`` processors in series. """ def __init__(self, width, height): """ :param width: The target width, in pixels. :param height: The target height, in pixels. """ self.width, self.height = width, height def process(self, img): img = Cover(self.width, self.height).process(img) return crop.SmartCrop(self.width, self.height).process(img) class Crop(Fill): def __init__(self, *args, **kwargs): warnings.warn('`imagekit.processors.resize.Crop` has been renamed to' '`imagekit.processors.resize.Fill`.', DeprecationWarning) super(Crop, self).__init__(*args, **kwargs) class ResizeCanvas(object): """ Resizes the canvas, using the provided background color if the new size is larger than the current image. """ def __init__(self, width, height, color=None, anchor=None, x=None, y=None): """ :param width: The target width, in pixels. :param height: The target height, in pixels. :param color: The background color to use for padding. :param anchor: Specifies the relative position of the original image. """ if x is not None or y is not None: if anchor: raise Exception('You may provide either an anchor or x and y' ' coordinate, but not both.') else: self.x, self.y = x or 0, y or 0 self.anchor = None else: self.anchor = anchor or Anchor.CENTER self.x = self.y = None self.width = width self.height = height self.color = color def process(self, img): new_img = Image.new('RGBA', (self.width, self.height), self.color) if self.anchor: x = int(abs(self.width - img.size[0]) * Anchor._ANCHOR_PTS[self.anchor][0]) y = int(abs(self.height - img.size[1]) * Anchor._ANCHOR_PTS[self.anchor][1]) else: x, y = self.x, self.y new_img.paste(img, (x, y)) return new_img class AddBorder(object): """ Add a border of specific color and size to an image. """ def __init__(self, thickness, color=None): """ :param color: Color to use for the border :param thickness: Thickness of the border. Can be either an int or a 4-tuple of ints of the form (top, right, bottom, left). """ self.color = color if isinstance(thickness, int): self.top = self.right = self.bottom = self.left = thickness else: self.top, self.right, self.bottom, self.left = thickness def process(self, img): new_width = img.size[0] + self.left + self.right new_height = img.size[1] + self.top + self.bottom return ResizeCanvas(new_width, new_height, color=self.color, x=self.left, y=self.top).process(img) class Fit(object): """ Resizes an image to fit within the specified dimensions. """ def __init__(self, width=None, height=None, upscale=None, mat_color=None, anchor=Anchor.CENTER): """ :param width: The maximum width of the desired image. :param height: The maximum height of the desired image. :param upscale: A boolean value specifying whether the image should be enlarged if its dimensions are smaller than the target dimensions. :param mat_color: If set, the target image size will be enforced and the specified color will be used as a background color to pad the image. """ self.width = width self.height = height self.upscale = upscale self.mat_color = mat_color self.anchor = anchor def process(self, img): cur_width, cur_height = img.size if not self.width is None and not self.height is None: ratio = min(float(self.width) / cur_width, float(self.height) / cur_height) else: if self.width is None: ratio = float(self.height) / cur_height else: ratio = float(self.width) / cur_width new_dimensions = (int(round(cur_width * ratio)), int(round(cur_height * ratio))) if (cur_width > new_dimensions[0] or cur_height > new_dimensions[1]) or \ self.upscale: img = BasicResize(new_dimensions[0], new_dimensions[1]).process(img) if self.mat_color: img = ResizeCanvas(self.width, self.height, self.mat_color, anchor=self.anchor).process(img) return img class SmartCrop(crop.SmartCrop): def __init__(self, *args, **kwargs): warnings.warn('The SmartCrop processor has been moved to' ' `imagekit.processors.crop.SmartCrop`, where it belongs.', DeprecationWarning) super(SmartCrop, self).__init__(*args, **kwargs)