def draw_googly(image_name, faces):
imagepath = 'img/' + image_name
for face in faces:
portrait = Image.open(imagepath)
rect = face['faceRectangle']
print('rectangle:', rect)
eye = Image.open('eye.png')
eye.thumbnail((rect['width'] / 3, rect['height'] / 3))
eye_size = eye.size[0]
offset = int(eye_size / 2)
eye_left_x = int(face['faceLandmarks']['pupilLeft']['x']) - offset
eye_left_y = int(face['faceLandmarks']['pupilLeft']['y']) - offset
eye_right_x = int(face['faceLandmarks']['pupilRight']['x']) - offset
eye_right_y = int(face['faceLandmarks']['pupilRight']['y']) - offset
# center it on face
paste_position_left = eye_left_x, eye_left_y
paste_position_right = eye_right_x, eye_right_y
# last property is a mask
portrait.paste(eye, paste_position_left, eye)
portrait.paste(eye, paste_position_right, eye)
# check if it has an alpha channel
if 'A' in portrait.getbands():
PillowImage(portrait).set_background_color_rgb(
(255, 255, 255)).save_as_jpeg(imagepath)
else:
portrait.save(imagepath)
if DEV == 'TRUE':
print('showing portrait.')
portrait.show()
def pillow_quantize(image):
try:
quantized_image = image.image.quantize(method=3)
except ValueError:
# libimagequant is missing, use the default method
quantized_image = image.image.quantize()
return PillowImage(quantized_image)
def run(self, willow, image, env):
# Note that `image` here is the database model of the Image, not the actual image
if image.width < self.width or image.height < self.height:
# unable to process image at all since the putalpha will fail
return
willow = super(CircleCropOperation, self).run(willow, image, env)
with image.get_willow_image() as willow_image:
original_format = willow_image.format_name
pillow_image = willow.image
# pillow_image.save('filled.{0}'.format(original_format))
# We can get fancy with transparencies...
if original_format == 'png':
mask = self._draw_circular_mask()
if self.border_width > 0:
# Add a border...
border_mask = self._draw_circular_mask(with_border=True)
draw = ImageDraw.Draw(pillow_image)
draw.bitmap((0, 0), border_mask, self.border_color)
del draw
# pillow_image.save('bitmap.png')
mask.paste(border_mask, (0, 0), border_mask)
# mask.save('pasted.png')
pillow_image.putalpha(mask)
else:
mask = self._draw_circular_mask(invert=True)
pillow_image.paste(mask, (0, 0), mask)
width, height = pillow_image.size
if self.border_width > 0:
draw = ImageDraw.Draw(pillow_image)
# We need this first ellipse which won't actually be a closed circle since we are using 'outline'...
_border_color = self.border_color
if draw.im.mode == 'L':
# 'L' implies the image is grayscale so providing (r, g, b[, alpha]) doesn't make any sense as there is one channel; it's expecting an integer
_border_color = self.border_color[0]
draw.ellipse((0, 0) + (width, height), outline=_border_color)
# Move in 1 pixel and draw another ellipse for each pixel of width
for i in range(self.border_width):
draw.ellipse(
(i + 1, i + 1) + (width - i - 1, height - i - 1),
outline=_border_color)
del draw
# pillow_image.save('masked.{0}'.format(original_format))
return PillowImage(pillow_image)
def fill_image(final_image_size, pillow, crop_closeness=0):
willow = PillowImage(pillow)
width, height = final_image_size
image_width, image_height = willow.get_size()
focal_point = Rect(image_width / 2, image_height / 2, image_width / 2,
image_height / 2)
# Get crop aspect ratio
crop_aspect_ratio = width / height
# Get crop max
crop_max_scale = min(image_width, image_height * crop_aspect_ratio)
crop_max_width = crop_max_scale
crop_max_height = crop_max_scale / crop_aspect_ratio
# Initialise crop width and height to max
crop_width = crop_max_width
crop_height = crop_max_height
# Use crop closeness to zoom in
if focal_point is not None:
# Get crop min
crop_min_scale = max(focal_point.width, focal_point.height * crop_aspect_ratio)
crop_min_width = crop_min_scale
crop_min_height = crop_min_scale / crop_aspect_ratio
# Sometimes, the focal point may be bigger than the image...
if not crop_min_scale >= crop_max_scale:
# Calculate max crop closeness to prevent upscaling
max_crop_closeness = max(
1 - (width - crop_min_width) / (crop_max_width - crop_min_width),
1 - (height - crop_min_height) / (crop_max_height - crop_min_height)
)
# Apply max crop closeness
crop_closeness = min(crop_closeness, max_crop_closeness)
if 1 >= crop_closeness >= 0:
# Get crop width and height
crop_width = crop_max_width + (crop_min_width - crop_max_width) * crop_closeness
crop_height = crop_max_height + (crop_min_height - crop_max_height) * crop_closeness
# Find focal point UV
if focal_point is not None:
fp_x, fp_y = focal_point.centroid
else:
# Fall back to positioning in the centre
fp_x = image_width / 2
fp_y = image_height / 2
fp_u = fp_x / image_width
fp_v = fp_y / image_height
# Position crop box based on focal point UV
crop_x = fp_x - (fp_u - 0.5) * crop_width
crop_y = fp_y - (fp_v - 0.5) * crop_height
# Convert crop box into rect
rect = Rect.from_point(crop_x, crop_y, crop_width, crop_height)
# Make sure the entire focal point is in the crop box
if focal_point is not None:
rect = rect.move_to_cover(focal_point)
# Don't allow the crop box to go over the image boundary
rect = rect.move_to_clamp(Rect(0, 0, image_width, image_height))
# Crop!
willow = willow.crop(rect.round())
# Get scale for resizing
# The scale should be the same for both the horizontal and
# vertical axes
aftercrop_width, aftercrop_height = willow.get_size()
scale = width / aftercrop_width
# Only resize if the image is too big
if scale < 1.0:
# Resize!
willow = willow.resize((width, height))
return willow.get_pillow_image()
def putalpha(self, willow, alpha):
willow.image.putalpha(alpha)
# willow.image.save('alpha.png')
return PillowImage(willow.image)
def draw_bitmap(self, willow, bitmap, fill):
draw = ImageDraw.Draw(willow.image)
draw.bitmap((0, 0), bitmap, fill)
del draw
# willow.image.save('bitmap.png')
return PillowImage(willow.image)
def run(self, willow, image, env):
return PillowImage(willow.get_pillow_image().convert('L'))
