From d870877967b5debc11d9364ba1572e7aa6956c28 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Theys?= <seb@odoo.com>
Date: Fri, 26 Apr 2019 10:55:21 +0000
Subject: [PATCH] [IMP] tools,base,web,website_*: keep image ratio on resize

* = website_partner, website_profile, website_sale, website_slides

Before
======

Since commit: 2e3848b394748bf23eff0db0d6d92b9e8c9bf875

The images that are resized have additional borders if the target ratio is
different than the image ratio. Those borders are transparent if the image
format supports it, and are white otherwise.

With that current solution, if the background where the image is displayed is
another color than white, it is looking really bad.

Moreover, most images are stored resized like this, so it is not even possible
to decide if it should have borders or not depending on the context, the
original image and ratio is forever lost.

It is also inconsistent because if the image is already smaller than the target
size then it doesn't include borders. In that case it keeps the original ratio
instead of the target ratio. So it isn't even guaranteed that the target
ratio is going to be respected.

After
=====

This commit will solve all of those problems by always keeping the ratio of the
original image.

This implies the views should be taking care of adding borders when necessary.

task-1958000
PR: #31811
---
 addons/product/models/product.py              |   2 +-
 addons/web/controllers/main.py                |   6 +-
 addons/web/models/ir_qweb.py                  |   3 +-
 addons/web/tests/test_image.py                |   4 +-
 .../views/website_partner_templates.xml       |   2 +-
 addons/website_profile/controllers/main.py    |   4 +-
 .../tests/test_website_sale_image.py          |  24 +--
 addons/website_slides/controllers/main.py     |   4 +-
 odoo/addons/base/models/image_mixin.py        |   2 +-
 odoo/addons/base/models/res_partner.py        |   4 +-
 odoo/addons/base/tests/test_image.py          |  53 +++----
 odoo/tools/image.py                           | 140 ++++--------------
 12 files changed, 75 insertions(+), 173 deletions(-)

diff --git a/addons/product/models/product.py b/addons/product/models/product.py
index 99a314662dd..4d566f2b100 100644
--- a/addons/product/models/product.py
+++ b/addons/product/models/product.py
@@ -168,7 +168,7 @@ class ProductProduct(models.Model):
         for record in self:
             images = tools.image_get_resized_images(record.image_raw_original, big_name=False)
             record.image_raw_big = tools.image_get_resized_images(record.image_raw_original,
-                large_name=False, medium_name=False, small_name=False, preserve_aspect_ratio=True)['image']
+                large_name=False, medium_name=False, small_name=False)['image']
             record.image_raw_large = images['image_large']
             record.image_raw_medium = images['image_medium']
             record.image_raw_small = images['image_small']
diff --git a/addons/web/controllers/main.py b/addons/web/controllers/main.py
index dc345e047ed..226d5347e84 100644
--- a/addons/web/controllers/main.py
+++ b/addons/web/controllers/main.py
@@ -1023,8 +1023,8 @@ class Binary(http.Controller):
         '/web/image/<int:id>-<string:unique>/<int:width>x<int:height>/<string:filename>'], type='http', auth="public")
     def content_image(self, xmlid=None, model='ir.attachment', id=None, field='datas',
                       filename_field='datas_fname', unique=None, filename=None, mimetype=None,
-                      download=None, width=0, height=0, crop=False, access_token=None, avoid_if_small=False,
-                      upper_limit=False, placeholder='placeholder.png', **kw):
+                      download=None, width=0, height=0, crop=False, access_token=None,
+                      placeholder='placeholder.png', **kwargs):
         status, headers, image_base64 = request.env['ir.http'].binary_content(
             xmlid=xmlid, model=model, id=id, field=field, unique=unique, filename=filename,
             filename_field=filename_field, download=download, mimetype=mimetype,
@@ -1041,7 +1041,7 @@ class Binary(http.Controller):
                     image_base64 = getattr(odoo.tools, 'image_resize_image_%s' % suffix)(image_base64)
 
         image_base64 = limited_image_resize(
-            image_base64, width=width, height=height, crop=crop, upper_limit=upper_limit, avoid_if_small=avoid_if_small)
+            image_base64, width=width, height=height, crop=crop)
 
         content = base64.b64decode(image_base64)
         headers.append(('Content-Length', len(content)))
diff --git a/addons/web/models/ir_qweb.py b/addons/web/models/ir_qweb.py
index d1d792e8f54..e8a966647e3 100644
--- a/addons/web/models/ir_qweb.py
+++ b/addons/web/models/ir_qweb.py
@@ -45,7 +45,6 @@ class Image(models.AbstractModel):
 
         sha = hashlib.sha1(str(getattr(record, '__last_update')).encode('utf-8')).hexdigest()[0:7]
         max_size = '' if max_size is None else '/%s' % max_size
-        avoid_if_small = '&avoid_if_small=true' if options.get('avoid_if_small') else ''
 
         if options.get('filename-field') and getattr(record, options['filename-field'], None):
             filename = record[options['filename-field']]
@@ -54,7 +53,7 @@ class Image(models.AbstractModel):
         else:
             filename = record.display_name
 
-        src = '/web/image/%s/%s/%s%s/%s?unique=%s%s' % (record._name, record.id, options.get('preview_image', field_name), max_size, url_quote(filename), sha, avoid_if_small)
+        src = '/web/image/%s/%s/%s%s/%s?unique=%s' % (record._name, record.id, options.get('preview_image', field_name), max_size, url_quote(filename), sha)
 
         if options.get('alt-field') and getattr(record, options['alt-field'], None):
             alt = escape(record[options['alt-field']])
diff --git a/addons/web/tests/test_image.py b/addons/web/tests/test_image.py
index e17073d0fb7..1e4b0c3c5b5 100644
--- a/addons/web/tests/test_image.py
+++ b/addons/web/tests/test_image.py
@@ -13,10 +13,10 @@ class TestImage(HttpCase):
         """The goal of this test is to make sure the placeholder image is
         resized appropriately depending on the given URL parameters."""
 
-        # CASE: resize placeholder to given size
+        # CASE: resize placeholder, given size but original ratio is always kept
         response = self.url_open('/web/image/0/200x150')
         image = Image.open(io.BytesIO(response.content))
-        self.assertEqual(image.size, (200, 150))
+        self.assertEqual(image.size, (150, 150))
 
         # CASE: resize placeholder to small
         response = self.url_open('/web/image/fake/0/image_small')
diff --git a/addons/website_partner/views/website_partner_templates.xml b/addons/website_partner/views/website_partner_templates.xml
index c8682008619..2f5c58b1dee 100644
--- a/addons/website_partner/views/website_partner_templates.xml
+++ b/addons/website_partner/views/website_partner_templates.xml
@@ -17,7 +17,7 @@
 <template id="partner_detail" name="Partner Details">
     <h1 class="col-lg-12 text-center" id="partner_name" t-field="partner.display_name"/>
     <div class="col-lg-4">
-        <div t-field="partner.image" t-options='{"widget": "image", "class": "d-block mx-auto mb16", "max_width": 512, "avoid_if_small": True}'/>
+        <div t-field="partner.image" t-options='{"widget": "image", "class": "d-block mx-auto mb16", "max_width": 512}'/>
         <address>
              <div t-field="partner.self" t-options='{
                  "widget": "contact",
diff --git a/addons/website_profile/controllers/main.py b/addons/website_profile/controllers/main.py
index fc1e9b70715..a15f30ade18 100644
--- a/addons/website_profile/controllers/main.py
+++ b/addons/website_profile/controllers/main.py
@@ -80,7 +80,7 @@ class WebsiteProfile(http.Controller):
     @http.route([
         '/profile/avatar/<int:user_id>',
     ], type='http', auth="public", website=True, sitemap=False)
-    def get_user_profile_avatar(self, user_id, field='image_large', width=0, height=0, crop=False, avoid_if_small=False, upper_limit=False, **post):
+    def get_user_profile_avatar(self, user_id, field='image_large', width=0, height=0, crop=False, **post):
         if field not in ('image_small', 'image_medium', 'image_large'):
             return werkzeug.exceptions.Forbidden()
 
@@ -102,7 +102,7 @@ class WebsiteProfile(http.Controller):
             image_base64 = self._get_default_avatar(field, headers, width, height)
 
         image_base64 = tools.limited_image_resize(
-            image_base64, width=width, height=height, crop=crop, upper_limit=upper_limit, avoid_if_small=avoid_if_small)
+            image_base64, width=width, height=height, crop=crop)
 
         content = base64.b64decode(image_base64)
         headers.append(('Content-Length', len(content)))
diff --git a/addons/website_sale/tests/test_website_sale_image.py b/addons/website_sale/tests/test_website_sale_image.py
index c873fffef15..f382d869dfa 100644
--- a/addons/website_sale/tests/test_website_sale_image.py
+++ b/addons/website_sale/tests/test_website_sale_image.py
@@ -167,37 +167,37 @@ class TestWebsiteSaleImage(odoo.tests.HttpCase):
         self.assertEqual(product_red.image_big, product_red.image)
         self.assertEqual(product_green.image_big, product_green.image)
 
-        # Verify large size
+        # Verify large size: keep aspect ratio
         image = Image.open(io.BytesIO(base64.b64decode(template.image_large)))
-        self.assertEqual(image.size, (256, 256))
+        self.assertEqual(image.size, (256, 144))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (65, 105, 225), "blue")
         image = Image.open(io.BytesIO(base64.b64decode(product_red.image_large)))
-        self.assertEqual(image.size, (256, 256))
+        self.assertEqual(image.size, (256, 160))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (205, 92, 92), "red")
         image = Image.open(io.BytesIO(base64.b64decode(product_green.image_large)))
-        self.assertEqual(image.size, (256, 256))
+        self.assertEqual(image.size, (256, 144))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (34, 139, 34), "green")
 
-        # Verify medium size
+        # Verify medium size: keep aspect ratio
         image = Image.open(io.BytesIO(base64.b64decode(template.image_medium)))
-        self.assertEqual(image.size, (128, 128))
+        self.assertEqual(image.size, (128, 72))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (65, 105, 225), "blue")
         image = Image.open(io.BytesIO(base64.b64decode(product_red.image_medium)))
-        self.assertEqual(image.size, (128, 128))
+        self.assertEqual(image.size, (128, 80))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (205, 92, 92), "red")
         image = Image.open(io.BytesIO(base64.b64decode(product_green.image_medium)))
-        self.assertEqual(image.size, (128, 128))
+        self.assertEqual(image.size, (128, 72))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (34, 139, 34), "green")
 
-        # Verify small size
+        # Verify small size: keep aspect ratio
         image = Image.open(io.BytesIO(base64.b64decode(template.image_small)))
-        self.assertEqual(image.size, (64, 64))
+        self.assertEqual(image.size, (64, 36))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (65, 105, 225), "blue")
         image = Image.open(io.BytesIO(base64.b64decode(product_red.image_small)))
-        self.assertEqual(image.size, (64, 64))
+        self.assertEqual(image.size, (64, 40))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (205, 92, 92), "red")
         image = Image.open(io.BytesIO(base64.b64decode(product_green.image_small)))
-        self.assertEqual(image.size, (64, 64))
+        self.assertEqual(image.size, (64, 36))
         self.assertEqual(image.getpixel((image.size[0] / 2, image.size[1] / 2)), (34, 139, 34), "green")
 
         # self.env.cr.commit()  # uncomment to save the product to test in browser
diff --git a/addons/website_slides/controllers/main.py b/addons/website_slides/controllers/main.py
index f2b0bb10c11..d8833c4d06e 100644
--- a/addons/website_slides/controllers/main.py
+++ b/addons/website_slides/controllers/main.py
@@ -506,7 +506,7 @@ class WebsiteSlides(WebsiteProfile):
         return response
 
     @http.route('/slides/slide/<int:slide_id>/get_image', type='http', auth="public", website=True, sitemap=False)
-    def slide_get_image(self, slide_id, field='image_medium', width=0, height=0, crop=False, avoid_if_small=False, upper_limit=False):
+    def slide_get_image(self, slide_id, field='image_medium', width=0, height=0, crop=False):
         # Protect infographics by limiting access to 256px (large) images
         if field not in ('image_small', 'image_medium', 'image_large'):
             return werkzeug.exceptions.Forbidden()
@@ -527,7 +527,7 @@ class WebsiteSlides(WebsiteProfile):
             image_base64 = self._get_default_avatar(field, headers, width, height)
 
         image_base64 = tools.limited_image_resize(
-            image_base64, width=width, height=height, crop=crop, upper_limit=upper_limit, avoid_if_small=avoid_if_small)
+            image_base64, width=width, height=height, crop=crop)
 
         content = base64.b64decode(image_base64)
         headers.append(('Content-Length', len(content)))
diff --git a/odoo/addons/base/models/image_mixin.py b/odoo/addons/base/models/image_mixin.py
index 9ef70b15bbd..1b186c993b4 100644
--- a/odoo/addons/base/models/image_mixin.py
+++ b/odoo/addons/base/models/image_mixin.py
@@ -28,7 +28,7 @@ class ImageMixin(models.AbstractModel):
         for record in self:
             images = tools.image_get_resized_images(record.image_original, big_name=False)
             record.image_big = tools.image_get_resized_images(record.image_original,
-                large_name=False, medium_name=False, small_name=False, preserve_aspect_ratio=True)['image']
+                large_name=False, medium_name=False, small_name=False)['image']
             record.image_large = images['image_large']
             record.image_medium = images['image_medium']
             record.image_small = images['image_small']
diff --git a/odoo/addons/base/models/res_partner.py b/odoo/addons/base/models/res_partner.py
index 6ac46332653..ebb76e24242 100644
--- a/odoo/addons/base/models/res_partner.py
+++ b/odoo/addons/base/models/res_partner.py
@@ -572,7 +572,7 @@ class Partner(models.Model):
                             ("The selected company is not compatible with the companies of the related user(s)"))
         # no padding on the big image, because it's used as website logo
         tools.image_resize_images(vals, return_big=False)
-        tools.image_resize_images(vals, return_medium=False, return_small=False, preserve_aspect_ratio=True)
+        tools.image_resize_images(vals, return_medium=False, return_small=False)
 
         result = True
         # To write in SUPERUSER on field is_company and avoid access rights problems.
@@ -601,7 +601,7 @@ class Partner(models.Model):
                 vals['image'] = self._get_default_image(vals.get('type'), vals.get('is_company'), vals.get('parent_id'))
             # no padding on the big image, because it's used as website logo
             tools.image_resize_images(vals, return_big=False)
-            tools.image_resize_images(vals, return_medium=False, return_small=False, preserve_aspect_ratio=True)
+            tools.image_resize_images(vals, return_medium=False, return_small=False)
         partners = super(Partner, self).create(vals_list)
 
         if self.env.context.get('_partners_skip_fields_sync'):
diff --git a/odoo/addons/base/tests/test_image.py b/odoo/addons/base/tests/test_image.py
index 58ed6c245e1..808bdc1ea88 100644
--- a/odoo/addons/base/tests/test_image.py
+++ b/odoo/addons/base/tests/test_image.py
@@ -20,7 +20,6 @@ class TestImage(TransactionCase):
     - image_resize_image_small
     - image_get_resized_images
     - image_resize_images
-    - image_resize_and_sharpen
     - is_image_size_above
     """
     def setUp(self):
@@ -72,13 +71,13 @@ class TestImage(TransactionCase):
         res = tools.image_resize_image(self.base64_svg)
         self.assertEqual(res, self.base64_svg)
 
-        # CASE: ok with default parameters
+        # CASE: ok with default parameters (keep ratio)
         image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080))
-        self.assertEqual(image.size, tools.IMAGE_BIG_SIZE)
+        self.assertEqual(image.size, (1024, 576))
 
-        # CASE: correct resize
+        # CASE: correct resize (keep ratio)
         image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(800, 600)))
-        self.assertEqual(image.size, (800, 600))
+        self.assertEqual(image.size, (800, 450))
 
         # CASE: change filetype to PNG
         image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, filetype='PNG'))
@@ -105,41 +104,33 @@ class TestImage(TransactionCase):
         image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(None, 108)))
         self.assertEqual(image.size, (192, 108))
 
-        # CASE: resize above original size
-        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(3000, 2000)))
-        self.assertEqual(image.size, (3000, 2000))
-
-        # CASE: avoid_if_small=True and size above, return original
-        res = tools.image_resize_image(self.base64_image_1920_1080, size=(3000, 2000), avoid_if_small=True)
+        # CASE: size above, return original
+        res = tools.image_resize_image(self.base64_image_1920_1080, size=(3000, 2000))
         self.assertEqual(res, self.base64_image_1920_1080)
 
-        # CASE: same size, no sharpen
+        # CASE: same size, no change
         res = tools.image_resize_image(self.base64_image_1920_1080, size=(1920, 1080))
         self.assertEqual(res, self.base64_image_1920_1080)
 
-        # CASE: upper_limit=True, no resize if above
-        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(3000, 2000), upper_limit=True))
-        self.assertEqual(image.size, (1920, 1080))
+        # CASE: no resize if above
+        res = tools.image_resize_image(self.base64_image_1920_1080, size=(3000, None))
+        self.assertEqual(res, self.base64_image_1920_1080)
 
-        # CASE: upper_limit=True, keep ratio, no resize if above
-        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(3000, None), upper_limit=True))
-        self.assertEqual(image.size, (1920, 1080))
+        # CASE: no resize if above
+        res = tools.image_resize_image(self.base64_image_1920_1080, size=(None, 2000))
+        self.assertEqual(res, self.base64_image_1920_1080)
 
-        # CASE: upper_limit=True, keep ratio, no resize if above
-        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(None, 2000), upper_limit=True))
-        self.assertEqual(image.size, (1920, 1080))
-
-        # CASE: upper_limit=True, vertical image, correct resize if below
+        # CASE: vertical image, correct resize if below
         base64_image_1080_1920 = tools.image_to_base64(PIL.Image.new('RGB', (1080, 1920)), 'PNG')
-        image = tools.base64_to_image(tools.image_resize_image(base64_image_1080_1920, size=(3000, 192), upper_limit=True))
+        image = tools.base64_to_image(tools.image_resize_image(base64_image_1080_1920, size=(3000, 192)))
         self.assertEqual(image.size, (108, 192))
 
-        # CASE: preserve_aspect_ratio=True, adapt to width
-        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(192, 200), preserve_aspect_ratio=True))
+        # CASE: adapt to width
+        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(192, 200)))
         self.assertEqual(image.size, (192, 108))
 
-        # CASE: preserve_aspect_ratio=True, adapt to height
-        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(400, 108), preserve_aspect_ratio=True))
+        # CASE: adapt to height
+        image = tools.base64_to_image(tools.image_resize_image(self.base64_image_1920_1080, size=(400, 108)))
         self.assertEqual(image.size, (192, 108))
 
     def test_11_image_optimize_for_web(self):
@@ -257,12 +248,8 @@ class TestImage(TransactionCase):
         image = tools.base64_to_image(tools.limited_image_resize(self.base64_image_1920_1080, width=192, height=108, crop=True))
         self.assertEqual(image.size, (108, 108))
 
-        # CASE: if not upper_limit, max 500px * 500px
+        # keep ratio
         image = tools.base64_to_image(tools.limited_image_resize(self.base64_image_1920_1080, width=1000, height=1000))
-        self.assertEqual(image.size, (500, 500))
-
-        # CASE: if upper_limit=True, no limit
-        image = tools.base64_to_image(tools.limited_image_resize(self.base64_image_1920_1080, width=1000, height=1000, upper_limit=True))
         self.assertEqual(image.size, (1000, 562))
 
     def test_17_image_data_uri(self):
diff --git a/odoo/tools/image.py b/odoo/tools/image.py
index e1a3b0e0328..7929857050e 100644
--- a/odoo/tools/image.py
+++ b/odoo/tools/image.py
@@ -4,7 +4,6 @@ import base64
 import io
 
 from PIL import Image
-from PIL import ImageEnhance
 from random import randrange
 
 from odoo.tools.translate import _
@@ -37,25 +36,10 @@ IMAGE_MAX_RESOLUTION = 45e6
 # Image resizing
 # ----------------------------------------
 
-def image_resize_image(base64_source, size=IMAGE_BIG_SIZE, filetype=None, avoid_if_small=False, preserve_aspect_ratio=False, upper_limit=False):
+def image_resize_image(base64_source, size=IMAGE_BIG_SIZE, filetype=None):
     """ Function to resize an image. The image will be resized to the given
-        size, while keeping the aspect ratios, and holes in the image will be
-        filled with transparent background. The image will not be stretched if
+        size, while keeping the aspect ratios. The image will not be resized if
         smaller than the expected size.
-        Steps of the resizing:
-        - Compute width and height if not specified.
-        - if avoid_if_small: if both image sizes are smaller than the requested
-          sizes, the original image is returned. This is used to avoid adding
-          transparent content around images that we do not want to alter but
-          just resize if too big. This is used for example when storing images
-          in the 'image' field: we keep the original image, resized to a maximal
-          size, without adding transparent content around it if smaller.
-        - create a thumbnail of the source image through using the thumbnail
-          function. Aspect ratios are preserved when using it. Note that if the
-          source image is smaller than the expected size, it will not be
-          extended, but filled to match the size.
-        - create a transparent background that will hold the final image.
-        - paste the thumbnail on the transparent background and center it.
 
         :param base64_source: base64-encoded version of the source
             image; if False, returns False
@@ -64,16 +48,15 @@ def image_resize_image(base64_source, size=IMAGE_BIG_SIZE, filetype=None, avoid_
             on height or width of the source image.
         :param filetype: the output filetype, by default the source image's
         :type filetype: str, any PIL image format (supported for creation)
-        :param avoid_if_small: do not resize if image height and width
-            are smaller than the expected size.
     """
     if not base64_source:
         return False
     # Return unmodified content if no resize or we etect first 6 bits of '<'
     # (0x3C) for SVG documents - This will bypass XML files as well, but it's
     # harmless for these purposes
-    if size == (None, None) or base64_source[:1] == b'P':
+    if base64_source[:1] == b'P':
         return base64_source
+
     image = base64_to_image(base64_source)
     # store filetype here, as Image.new below will lose image.format
     filetype = (filetype or image.format).upper()
@@ -82,64 +65,19 @@ def image_resize_image(base64_source, size=IMAGE_BIG_SIZE, filetype=None, avoid_
         'BMP': 'PNG',
     }.get(filetype, filetype)
 
-    asked_width, asked_height = size
-    if upper_limit:
-        if asked_width:
-            asked_width = min(asked_width, image.size[0])
-        if asked_height:
-            asked_height = min(asked_height, image.size[1])
+    if size and (size[0] or size[1]):
+        w, h = image.size
+        asked_width = size[0] or (w * size[1]) // h
+        asked_height = size[1] or (h * size[0]) // w
 
-        if image.size[0] >= image.size[1]:
-            asked_height = None
-        else:
-            asked_width = None
-        if asked_width is None and asked_height is None:
-            return base64_source
+        image.thumbnail((asked_width, asked_height), Image.LANCZOS)
 
-    if asked_width is None:
-        asked_width = int(image.size[0] * (float(asked_height) / image.size[1]))
-    if asked_height is None:
-        asked_height = int(image.size[1] * (float(asked_width) / image.size[0]))
-    size = asked_width, asked_height
-    # check image size: do not create a thumbnail if avoiding smaller images
-    if avoid_if_small and image.size[0] <= size[0] and image.size[1] <= size[1]:
-        return base64_source
-
-    if image.size != size:
-        image = image_resize_and_sharpen(image, size, preserve_aspect_ratio=preserve_aspect_ratio)
     if image.mode not in ["1", "L", "P", "RGB", "RGBA"] or (filetype == 'JPEG' and image.mode == 'RGBA'):
         image = image.convert("RGB")
 
     return image_to_base64(image, filetype)
 
 
-def image_resize_and_sharpen(image, size, preserve_aspect_ratio=False, factor=2.0):
-    """
-        Create a thumbnail by resizing while keeping ratio.
-        A sharpen filter is applied for a better looking result.
-
-        :param image: PIL.Image.Image()
-        :param size: 2-tuple(width, height)
-        :param preserve_aspect_ratio: boolean (default: False)
-        :param factor: Sharpen factor (default: 2.0)
-    """
-    origin_mode = image.mode
-    if image.mode != 'RGBA':
-        image = image.convert('RGBA')
-    image.thumbnail(size, Image.LANCZOS)
-    if preserve_aspect_ratio:
-        size = image.size
-    sharpener = ImageEnhance.Sharpness(image)
-    resized_image = sharpener.enhance(factor)
-    # create a transparent image for background and paste the image on it
-    image = Image.new('RGBA', size, (255, 255, 255, 0))
-    image.paste(resized_image, ((size[0] - resized_image.size[0]) // 2, (size[1] - resized_image.size[1]) // 2))
-
-    if image.mode != origin_mode:
-        image = image.convert(origin_mode)
-    return image
-
-
 def image_optimize_for_web(base64_source, max_width=0, quality=80):
     """Return the given `base64_source` optimized for web usage.
 
@@ -197,36 +135,36 @@ def image_optimize_for_web(base64_source, max_width=0, quality=80):
     return image_to_base64(image, **opt)
 
 
-def image_resize_image_big(base64_source, filetype=None, avoid_if_small=True, preserve_aspect_ratio=False, upper_limit=False):
+def image_resize_image_big(base64_source, filetype=None):
     """ Wrapper on image_resize_image, to resize images larger than the standard
         'big' image size: 1024x1024px.
         Refer to image_resize_image for the parameters.
     """
-    return image_resize_image(base64_source, IMAGE_BIG_SIZE, filetype, avoid_if_small, preserve_aspect_ratio, upper_limit)
+    return image_resize_image(base64_source, IMAGE_BIG_SIZE, filetype)
 
 
-def image_resize_image_large(base64_source, filetype=None, avoid_if_small=True, preserve_aspect_ratio=False, upper_limit=False):
+def image_resize_image_large(base64_source, filetype=None):
     """ Wrapper on image_resize_image, to resize to the standard 'large'
         image size: 256x256.
         Refer to image_resize_image for the parameters.
     """
-    return image_resize_image(base64_source, IMAGE_LARGE_SIZE, filetype, avoid_if_small, preserve_aspect_ratio, upper_limit)
+    return image_resize_image(base64_source, IMAGE_LARGE_SIZE, filetype)
 
 
-def image_resize_image_medium(base64_source, filetype=None, avoid_if_small=False, preserve_aspect_ratio=False, upper_limit=False):
+def image_resize_image_medium(base64_source, filetype=None):
     """ Wrapper on image_resize_image, to resize to the standard 'medium'
         image size: 128x128.
         Refer to image_resize_image for the parameters.
     """
-    return image_resize_image(base64_source, IMAGE_MEDIUM_SIZE, filetype, avoid_if_small, preserve_aspect_ratio, upper_limit)
+    return image_resize_image(base64_source, IMAGE_MEDIUM_SIZE, filetype)
 
 
-def image_resize_image_small(base64_source, filetype=None, avoid_if_small=False, preserve_aspect_ratio=False, upper_limit=False):
+def image_resize_image_small(base64_source, filetype=None):
     """ Wrapper on image_resize_image, to resize to the standard 'small' image
         size: 64x64.
         Refer to image_resize_image for the parameters.
     """
-    return image_resize_image(base64_source, IMAGE_SMALL_SIZE, filetype, avoid_if_small, preserve_aspect_ratio, upper_limit)
+    return image_resize_image(base64_source, IMAGE_SMALL_SIZE, filetype)
 
 
 # ----------------------------------------
@@ -351,9 +289,7 @@ def is_image_size_above(base64_source, size=IMAGE_BIG_SIZE):
 
 
 def image_get_resized_images(base64_source,
-        big_name='image', large_name='image_large', medium_name='image_medium', small_name='image_small',
-        avoid_resize_big=True, avoid_resize_large=True, avoid_resize_medium=True, avoid_resize_small=True,
-        preserve_aspect_ratio=False, upper_limit=False):
+        big_name='image', large_name='image_large', medium_name='image_medium', small_name='image_small'):
     """ Standard tool function that returns a dictionary containing the
         big, medium, large and small versions of the source image.
 
@@ -368,20 +304,19 @@ def image_get_resized_images(base64_source,
     """
     return_dict = dict()
     if big_name:
-        return_dict[big_name] = image_resize_image_big(base64_source, avoid_if_small=avoid_resize_big, preserve_aspect_ratio=preserve_aspect_ratio, upper_limit=upper_limit)
+        return_dict[big_name] = image_resize_image_big(base64_source)
     if large_name:
-        return_dict[large_name] = image_resize_image_large(base64_source, avoid_if_small=avoid_resize_large, preserve_aspect_ratio=preserve_aspect_ratio, upper_limit=upper_limit)
+        return_dict[large_name] = image_resize_image_large(base64_source)
     if medium_name:
-        return_dict[medium_name] = image_resize_image_medium(base64_source, avoid_if_small=avoid_resize_medium, preserve_aspect_ratio=preserve_aspect_ratio, upper_limit=upper_limit)
+        return_dict[medium_name] = image_resize_image_medium(base64_source)
     if small_name:
-        return_dict[small_name] = image_resize_image_small(base64_source, avoid_if_small=avoid_resize_small, preserve_aspect_ratio=preserve_aspect_ratio, upper_limit=upper_limit)
+        return_dict[small_name] = image_resize_image_small(base64_source)
     return return_dict
 
 
 def image_resize_images(vals,
         return_big=True, return_large=False, return_medium=True, return_small=True,
-        big_name='image', large_name='image_large', medium_name='image_medium', small_name='image_small',
-        preserve_aspect_ratio=False, upper_limit=False):
+        big_name='image', large_name='image_large', medium_name='image_medium', small_name='image_small'):
     """ Update ``vals`` with image fields resized as expected. """
     big_image = vals.get(big_name)
     large_image = vals.get(large_name)
@@ -392,11 +327,7 @@ def image_resize_images(vals,
 
     if biggest_image:
         vals.update(image_get_resized_images(biggest_image,
-            big_name=return_big and big_name, large_name=return_large and large_name, medium_name=return_medium and medium_name, small_name=return_small and small_name,
-            avoid_resize_big=True, avoid_resize_large=True,
-            avoid_resize_medium=(not big_image and not large_image),
-            avoid_resize_small=(not big_image and not large_image and not medium_image),
-            preserve_aspect_ratio=preserve_aspect_ratio, upper_limit=upper_limit))
+            big_name=return_big and big_name, large_name=return_large and large_name, medium_name=return_medium and medium_name, small_name=return_small and small_name))
     elif any(f in vals for f in [big_name, large_name, medium_name, small_name]):
         if return_big:
             vals[big_name] = False
@@ -408,7 +339,7 @@ def image_resize_images(vals,
             vals[small_name] = False
 
 
-def limited_image_resize(base64_source, width=None, height=None, crop=False, upper_limit=False, avoid_if_small=False):
+def limited_image_resize(base64_source, width=None, height=None, crop=False):
     """Return the given `base64_source` image resized to the given `width` and
     `height`. Return the original image if both `width` and `height` are fasly.
 
@@ -422,32 +353,17 @@ def limited_image_resize(base64_source, width=None, height=None, crop=False, upp
     :type height: int
 
     :param crop: True if the result should be cropped to a square.
-        False to resize without cropping, then the result will be controlled
-        by `upper_limit` and `avoid_if_small`
+        False to resize without cropping.
     :type crop: bool
 
-    :param upper_limit: value sent to `image_resize_image` if `crop` is False
-    :type upper_limit: bool
-
-    :param avoid_if_small: value sent to `image_resize_image` if `crop` is False
-    :type avoid_if_small: bool
-
     :return: resulting image base64 encoded
     :rtype: string or bytes
     """
     if base64_source and (width or height):
-        height = int(height or 0)
-        width = int(width or 0)
         if crop:
-            return crop_image(base64_source, type='center', size=(width or None, height or None), ratio=(1, 1))
+            return crop_image(base64_source, type='center', size=(width, height), ratio=(1, 1))
         else:
-            if not upper_limit:
-                # resize maximum 500*500
-                width = min(width, 500)
-                height = min(height, 500)
-            return image_resize_image(
-                base64_source=base64_source, size=(width or None, height or None), upper_limit=upper_limit,
-                avoid_if_small=avoid_if_small)
+            return image_resize_image(base64_source=base64_source, size=(width, height))
     return base64_source