Bantal - Mengubah ukuran GIF

Menggunakan skrip BigglesZX, saya telah membuat skrip baru yang mengubah ukuran GIF menggunakan Pillow.

GIF Asli (2,1 MB):

Keluaran GIF setelah diubah ukurannya (1,7 MB):

Saya telah menyimpan skrip di sini. Itu menggunakan metode thumbnail dari Bantal daripada metode resize karena menurut saya metode resize tidak berhasil.

Ini tidak sempurna jadi silakan bercabang dan memperbaikinya. Berikut beberapa masalah yang belum terselesaikan:

• Meskipun GIF ditampilkan dengan baik saat dihosting oleh imgur, ada masalah kecepatan saat saya membukanya dari komputer di mana keseluruhan GIF hanya membutuhkan waktu 1,5 detik.
• Demikian pula, meskipun imgur tampaknya mengatasi masalah kecepatan, GIF tidak ditampilkan dengan benar ketika saya mencoba mengunggahnya ke stack.imgur. Hanya frame pertama yang ditampilkan (Anda dapat melihatnya di sini).

Kode lengkap (jika inti di atas dihapus):

def resize_gif(path, save_as=None, resize_to=None):
    """
    Resizes the GIF to a given length:

    Args:
        path: the path to the GIF file
        save_as (optional): Path of the resized gif. If not set, the original gif will be overwritten.
        resize_to (optional): new size of the gif. Format: (int, int). If not set, the original GIF will be resized to
                              half of its size.
    """
    all_frames = extract_and_resize_frames(path, resize_to)

    if not save_as:
        save_as = path

    if len(all_frames) == 1:
        print("Warning: only 1 frame found")
        all_frames[0].save(save_as, optimize=True)
    else:
        all_frames[0].save(save_as, optimize=True, save_all=True, append_images=all_frames[1:], loop=1000)


def analyseImage(path):
    """
    Pre-process pass over the image to determine the mode (full or additive).
    Necessary as assessing single frames isn't reliable. Need to know the mode
    before processing all frames.
    """
    im = Image.open(path)
    results = {
        'size': im.size,
        'mode': 'full',
    }
    try:
        while True:
            if im.tile:
                tile = im.tile[0]
                update_region = tile[1]
                update_region_dimensions = update_region[2:]
                if update_region_dimensions != im.size:
                    results['mode'] = 'partial'
                    break
            im.seek(im.tell() + 1)
    except EOFError:
        pass
    return results


def extract_and_resize_frames(path, resize_to=None):
    """
    Iterate the GIF, extracting each frame and resizing them

    Returns:
        An array of all frames
    """
    mode = analyseImage(path)['mode']

    im = Image.open(path)

    if not resize_to:
        resize_to = (im.size[0] // 2, im.size[1] // 2)

    i = 0
    p = im.getpalette()
    last_frame = im.convert('RGBA')

    all_frames = []

    try:
        while True:
            # print("saving %s (%s) frame %d, %s %s" % (path, mode, i, im.size, im.tile))

            '''
            If the GIF uses local colour tables, each frame will have its own palette.
            If not, we need to apply the global palette to the new frame.
            '''
            if not im.getpalette():
                im.putpalette(p)

            new_frame = Image.new('RGBA', im.size)

            '''
            Is this file a "partial"-mode GIF where frames update a region of a different size to the entire image?
            If so, we need to construct the new frame by pasting it on top of the preceding frames.
            '''
            if mode == 'partial':
                new_frame.paste(last_frame)

            new_frame.paste(im, (0, 0), im.convert('RGBA'))

            new_frame.thumbnail(resize_to, Image.ANTIALIAS)
            all_frames.append(new_frame)

            i += 1
            last_frame = new_frame
            im.seek(im.tell() + 1)
    except EOFError:
        pass

    return all_frames

Menurut Pillow 4.0x, fungsi Image.resize hanya berfungsi pada satu gambar/bingkai.

Untuk mencapai apa yang Anda inginkan, saya yakin Anda harus terlebih dahulu mengekstrak setiap frame dari file .gif, mengubah ukuran setiap frame satu per satu, lalu memasangnya kembali.

Untuk melakukan langkah pertama, tampaknya ada beberapa detail yang perlu diperhatikan. Misalnya. apakah setiap bingkai gif menggunakan palet lokal atau palet global diterapkan pada semua bingkai, dan apakah gif mengganti setiap gambar menggunakan bingkai penuh atau sebagian. BigglesZX telah mengembangkan skrip untuk mengatasi masalah ini sambil mengekstrak setiap frame dari file gif, jadi manfaatkan hal itu .

Selanjutnya, Anda harus menulis skrip untuk mengubah ukuran setiap frame yang diekstraksi dan merakit semuanya sebagai .gif baru menggunakan PIL.Image.resize() dan PIL.Image.save().

Saya perhatikan Anda menulis "im.seek(im.tell() + 1) # load all frames". Menurut saya ini tidak benar. Melainkan digunakan untuk menambah antar frame file .gif. Saya perhatikan Anda menggunakan quality=10 dalam fungsi penyimpanan untuk file .gif Anda. Saya tidak menemukan ini seperti yang disediakan dalam dokumentasi PIL. Anda dapat mempelajari lebih lanjut tentang atribut ubin yang disebutkan dalam skrip BiggleZX dengan membaca tautan

Saya menggunakan fungsi di bawah ini untuk mengubah ukuran dan memotong gambar termasuk gambar animasi (GIF, WEBP) Sederhananya, kita perlu mengulangi setiap frame di gif atau webp.

from math import floor, fabs
from PIL import Image, ImageSequence

def transform_image(original_img, crop_w, crop_h):
  """
  Resizes and crops the image to the specified crop_w and crop_h if necessary.
  Works with multi frame gif and webp images also.

  args:
  original_img is the image instance created by pillow ( Image.open(filepath) )
  crop_w is the width in pixels for the image that will be resized and cropped
  crop_h is the height in pixels for the image that will be resized and cropped

  returns:
  Instance of an Image or list of frames which they are instances of an Image individually
  """
  img_w, img_h = (original_img.size[0], original_img.size[1])
  n_frames = getattr(original_img, 'n_frames', 1)

  def transform_frame(frame):
    """
    Resizes and crops the individual frame in the image.
    """
    # resize the image to the specified height if crop_w is null in the recipe
    if crop_w is None:
      if crop_h == img_h:
        return frame
      new_w = floor(img_w * crop_h / img_h)
      new_h = crop_h
      return frame.resize((new_w, new_h))

    # return the original image if crop size is equal to img size
    if crop_w == img_w and crop_h == img_h:
      return frame

    # first resize to get most visible area of the image and then crop
    w_diff = fabs(crop_w - img_w)
    h_diff = fabs(crop_h - img_h)
    enlarge_image = True if crop_w > img_w or crop_h > img_h else False
    shrink_image = True if crop_w < img_w or crop_h < img_h else False

    if enlarge_image is True:
      new_w = floor(crop_h * img_w / img_h) if h_diff > w_diff else crop_w
      new_h = floor(crop_w * img_h / img_w) if h_diff < w_diff else crop_h

    if shrink_image is True:
      new_w = crop_w if h_diff > w_diff else floor(crop_h * img_w / img_h)
      new_h = crop_h if h_diff < w_diff else floor(crop_w * img_h / img_w)

    left = (new_w - crop_w) // 2
    right = left + crop_w
    top = (new_h - crop_h) // 2
    bottom = top + crop_h

    return frame.resize((new_w, new_h)).crop((left, top, right, bottom))

  # single frame image
  if n_frames == 1:
    return transform_frame(original_img)
  # in the case of a multiframe image
  else:
    frames = []
    for frame in ImageSequence.Iterator(original_img):
      frames.append( transform_frame(frame) )
    return frames