Cara menggunakan python read gif

Conversion of video to gif using Python

Hello, in this tutorial we will learn how to convert video to gif in Python. For that, we use python.
Gifs are basically the compressed format of the video and they are used in places where very few colors are used, they are mostly used in logos as such. These gifs are compressed using lossless data compression in-order not to degrade the video quality.

Table of Contents

• Conversion of video to gif using Python
• Necessary libraries to convert video to gif in Python:
• Here is the  code to convert any videos into gifs:
• Save HTML as GIF in Python
• How to convert HTML to GIF
• Python library to convert HTML to GIF
• System Requirements
• How do you make a GIF with Python?
• How do I turn a code into a GIF?
• Can pygame load gifs?
• Can we add GIF in tkinter?

Necessary libraries to convert video to gif in Python:

$ pip install MoviePy

Once the package is installed, the further process is simple.

Here is the  code to convert any videos into gifs:

from moviepy.editor import *

clip = (VideoFileClip("ENTER THE FILE PATH HERE"))
clip.write_gif("output.gif")

The above code works for any videos.

If you want to select a particular part of the video to make the gif then we use the method .subclip(), wherein you can select the start and the end of the video.
And this is the code for the above problem

from moviepy.editor import * 
clip = (VideoFileClip("PATH NAME").subclip((START TIME),(END TIME)) .resize(ACCORDING TO THE USER WISH)) 
clip.write_gif("output.gif")

from moviepy.editor import *

clip = (VideoFileClip("/Users/nikhilgovind/Documents/input.mp4").subclip((22.65),(25.2))
        .resize(0.3))
clip.write_gif("output.gif")

There are other methods to convert video to gifs here we use moviepy.
We can also try ffmpy method which is pretty simple as the one shown above.

Here is the actual video before converting:

input.mp4

Here is the gif:

This is how the conversion is done. As you can observe the quality of the gif is reduced compared to that of the video as well as the gif runs in an infinite loop and there is no control over it. The sound is also removed.

This is all about the conversion of a video into a gif. Hope this tutorial has helped.
Also, read:

• Face Recognition from video in python using OpenCV
• How To Create A Countdown In Python

Need to convert HTML to GIF image programmatically? With Aspose.Words for Python via .NET any developer can easily transform HTML to GIF image format with just a few lines of Python code.

Modern document-processing Python API creates GIF from HTML with high speed. Test the quality of HTML to GIF conversion right in a browser. Powerful Python library allows converting HTML files to many popular image formats.

Save HTML as GIF in Python

The following example demonstrates how to convert HTML to a GIF picture in Python.

Follow the easy steps to turn a HTML file into GIF graphical format. Read HTML from the local drive, then simply save it as GIF, specifying the required image format by GIF extension. For both HTML reading and GIF writing you can use fully qualified filenames. The output GIF graphical content will be identical to the original HTML file.

How to convert HTML to GIF

1. Install 'Aspose.Words for Python via .NET'.
2. Add a library reference (import the library) to your Python project.
3. Open the source HTML file in Python.
4. Call the 'save()' method, passing an output filename with GIF extension.
5. Get the result of HTML conversion as GIF.

Python library to convert HTML to GIF

We host our Python packages in PyPi repositories. Please follow the step-by-step instructions on how to install "Aspose.Words for Python via .NET" to your developer environment.

System Requirements

This package is compatible with Python 3.5, 3.6, 3.7, 3.8 and 3.9. If you develop software for Linux, please have a look at additional requirements for gcc and libpython in Product Documentation.

Convert Mp4 Video To Gif Animation In Python

Convert Mp4 Video To Gif Animation In Python You can use Python to convert MP4 videos to animated GIF images. Of course, off-the-shelf applications do an excellent job. However, creating your own converter with Python is an interesting and useful experience.

In this tutorial we will take a look at the following tasks:

Extracting frames from MP4 videos.

Converting frames to GIF animation.

Creating a user interface for the converter program.

Let’s get started.

What We Will Need

Python uses the OpenCV library to recognize MP4 videos, extract and convert frames to JPG format. Let’s install it using pip, the package management system:

python3 -m pip install opencv-python

In addition, to create GIF animations from frames saved as JPGs, we also need the Pillow library. It is installed with pip:

python3 -m pip install Pillow

In order to create a graphical user interface, we will use the PySimpleGUI package. Let’s install it with the following command:

python3 -m pip install PySimpleGUI

Users of the Anaconda development environment do not need to install OpenCV and Pillow – they are already included in the component set. For Anaconda, you need to additionally install only PySimpleGUI.

Extracting Frames From Mp4 Videos

Firstly, in creating a GIF animation is to choose a video from which to extract the frames you want. Furthermore, in our case, we will use a video that demonstrates the process of installing the Flask framework, which is used for web development in Python.

Moreover, you need to write a special function to extract the individual frames. You should create a new file, name it mp4_converter and paste the following code into it:

import cv2

defconvert_mp4_to_jpgs(path):

    video_capture = cv2.VideoCapture(path)

    still_reading, image = video_capture.read()

    frame_count = 0

    whilestill_reading:

        cv2.imwrite(f”output/frame_{frame_count:03d}.jpg”, image)

        # read next image

        still_reading, image = video_capture.read()

        frame_count += 1

if __name__ == “__main__”:

    convert_mp4_to_jpgs(“flask_demo.mp4”)

This function takes the path to the MP4 file. Then it opens the video using the cv2.VideoCapture(path) method. Secondly, you can use this method to save the whole video frame by frame if you want. Thridly, to save the extracted frames, use the cv2.imwrite() method.

Moreover, after executing the code, you’ll see that there are as many as 235 frames in the 7-second video. In addition, after the frames are saved, you can start creating an animated GIF image.

Creating A Gif Animation From Single Images

At this step, you’ll write code to create a GIF image based on the frames we’ve extracted from an MP4 video with OpenCV.

Here we need Pillow library – with its help you can turn a set of images in a specified directory into a GIF animation. Create a new file, name it gif_maker, and save the code below to it:

importglob

fromPILimport Image

defmake_gif(frame_folder):

    images = glob.glob(f”{frame_folder}/*.jpg”)

    images.sort()

    frame_one = frames[0]

    frames = [Image.open(image) for imagein images]

    frame_one.save(“flask_demo.gif”, format=“GIF“, append_images=frames,

                   save_all=True, duration=50, loop=0)

if __name__ ==“__main__”:

    make_gif(“output”)

Firstly, in this code snippet, Python uses the glob module to search for JPG files. After that, the frames are sorted in the right order, and in the final step, the JPG images are saved in GIF format.

Now we are ready to create the user interface of our converter.

Interface For An Application That Converts Mp4 To Gif

Firstly, PySimpleGUI is a cross-platform framework: it works on Linux, Mac OS, and Windows. Furthermore, this package includes several libraries for UI development, including Tkinter, wxPython, and PyQt. So when you installinstalled PySimpleGUI in the first step, you have Tkinter at your disposal by default.

Secondly, create a new file in the development environment, name it mp4_converter_gui, save the code below to it:

# mp4_converter_gui.py

import cv2

import glob

import os

import shutil

import PySimpleGUI as sg

from PIL import Image

file_types = [(“MP4 (*.mp4)”, “*.mp4”), (“All files (*.*)”, “*.*”)]

defconvert_mp4_to_jpgs(path):

    video_capture = cv2.VideoCapture(path)

    still_reading, image = video_capture.read()

    frame_count = 0

    if os.path.exists(“output”):

        # remove previous GIF frame files

        shutil.rmtree(“output”)

    try:

        os.mkdir(“output”)

    except IOError:

        sg.popup(“Error occurred creating output folder”)

        return

    while still_reading:

        cv2.imwrite(f”output/frame_{frame_count:05d}.jpg”, image)

        # read next image

        still_reading, image = video_capture.read()

        frame_count += 1

defmake_gif(gif_path, frame_folder=“output”):

    images = glob.glob(f”{frame_folder}/*.jpg”)

    images.sort()

    frames = [Image.open(image) for image in images]

    frame_one = frames[0]

    frame_one.save(gif_path, format=“GIF”, append_images=frames,

                   save_all=True, duration=50, loop=0)

defmain():

    layout = [

        [

            sg.Text(“MP4 File”),

            sg.Input(size=(25, 1), key=“-FILENAME-“, disabled=True),

            sg.FileBrowse(file_types=file_types),

        ],

        [

            sg.Text(“GIF File Save Location”),

            sg.Input(size=(25, 1), key=“-OUTPUTFILE-“, disabled=True),

            sg.SaveAs(file_types=file_types),

        ],

        [sg.Button(“Convert to GIF”)],

    ]

    window = sg.Window(“MP4 to GIF Converter”, layout)

    whileTrue:

        event, values = window.read()

        mp4_path = values[“-FILENAME-“]

        gif_path = values[“-OUTPUTFILE-“]

        if event == “Exit”or event == sg.WIN_CLOSED:

            break

        if event in [“Convert to GIF”]:

            if mp4_path and gif_path:

                convert_mp4_to_jpgs(mp4_path)

                make_gif(gif_path)

                sg.popup(f”GIF created: {gif_path}“)

    window.close()

if __name__ == “__main__”:

    main()

The code is quite long. Moreover, to make it easier to understand, let’s look at each step separately.

At the very beginning is the module import section:

# mp4_converter_gui.py

import cv2

import glob

import os

import shutil

import PySimpleGUI as sg

from PIL import Image

file_types = [(“MP4 (*.mp4)”, “*.mp4”), (“All files (*.*)”, “*.*”)]

This snippet imports into the application all the modules and packages needed to create the GUI, the graphical user interface. OpenCV (cv2), Pillow Image class, and PySimpleGUI, as well as several modules from the standard Python set, are involved in this process. Also, at this point, a variable is declared to which all allowable file formats are passed in the tuple list.

Let’s move on to the first function of the program:

defconvert_mp4_to_jpgs(path):

    video_capture = cv2.VideoCapture(path)

    still_reading, image = video_capture.read()

    frame_count = 0

    if os.path.exists(“output”):

        # remove previous GIF frame files

        shutil.rmtree(“output”)

    try:

        os.mkdir(“output”)

    except IOError:

        sg.popup(“Error occurred creating output folder”)

        return

    while still_reading:

        cv2.imwrite(f”output/frame_{frame_count:05d}.jpg”, image)

        # read next image

        still_reading, image = video_capture.read()

        frame_count += 1

Firstly, this is a slightly modified version of the feature we created in the first step. As in the original version, we used the VideoCapture() method here to capture frames from MP4 videos and then save them as separate images.

However, this time we added a check for the existence and deletion of the output folder – in order to avoid accidentally saving frames from two MP4 files in the same directory: such a mixed set would make a very strange gif.

The next code snippet creates the output folder after deleting the existing one or generates an error message in case of a malfunction. In conclusion, the rest of the code is unchanged.

Let’s move on to the next function:

defmake_gif(gif_path, frame_folder=“output”):

    images = glob.glob(f”{frame_folder}/*.jpg”)

    images.sort()

    frames = [Image.open(image) for image in images]

    frame_one = frames[0]

    frame_one.save(gif_path, format=“GIF”, append_images=frames,

                   save_all=True, duration=50, loop=0)

Here we use the make_gif() method to create a GIF file. The code is almost the same as in the original version, except here we pass the path to the GIF file so that each animation is saved with a new name.

In conclusion, the final part of the code describes the window parameters and the application interface:

defmain():

    layout = [

        [

            sg.Text(“MP4 File”),

            sg.Input(size=(25, 1), key=“-FILENAME-“, disabled=True),

            sg.FileBrowse(file_types=file_types),

        ],

        [

            sg.Text(“GIF File Save Location”),

            sg.Input(size=(25, 1), key=“-OUTPUTFILE-“, disabled=True),

            sg.SaveAs(file_types=file_types),

        ],

        [sg.Button(“Convert to GIF”)],

    ]

    window = sg.Window(“MP4 to GIF Converter”, layout)

    whileTrue:

        event, values = window.read()

        mp4_path = values[“-FILENAME-“]

        gif_path = values[“-OUTPUTFILE-“]

        if event == “Exit”or event == sg.WIN_CLOSED:

            break

        if event in [“Convert to GIF”]:

            if mp4_path and gif_path:

                convert_mp4_to_jpgs(mp4_path)

                make_gif(gif_path)

                sg.popup(f”GIF created: {gif_path}“)

    window.close()

if __name__ == “__main__”:

    main()

When using the PySimpleGUI framework, the Elements interface elements are included in the layout list. For example, in our project, the Elements list includes the following UI elements:

Text – two objects that are used as the names of text input fields.

Input – also in duplicate. Moreover, one input field contains the path to the MP4 file, the other displays the path to the saved GIF file.

FileBrowse – button to open the “Find File” dialog box.

SaveAs – the “Save File” button to write the GIF file with the desired name.

Button – for starting the conversion process.

The next step is to pass the list of interface elements to the sg.Window object, which is responsible for displaying the application window. In addition, the window has a name, buttons to minimize, maximize and exit the program.

To handle events in the application window we create a while loop and read the events of the Window object. In this way, we get the values from the two objects sg.Input() which contains the paths to the MP4 and GIF files.

When the user clicks the “Convert to GIF” button, the program intercepts the event and calls first convert_mp4_to_jpgs() and then make_gif(). Moreover, if the conversion process completes successfully, a pop-up window will notify the user that the GIF file was created and show the path to it.

Run the execution of the code. You will see a window like this:

Not bad, right?

Let Us Summarize

Now you have all the code you need to convert MP4 videos to GIF animation. You can improve some things in our program – try for example to add error handling to functions in order not to accidentally overwrite old GIF files with new ones.

Moreover, you can also provide for reducing the size of frames, this reduces the final size of the GIF animation. Another way to reduce GIF files is to compress JPG frames before creating the animation.

In conclusion, there are other ways to improve and augment the code discussed in this guide. In addition, think about what other functionality this application is missing, and add it.

Convert Mp4 Video To Gif Animation In Python

Effie J Franks specializes in writing articles on such topics as Web Design and Python. She likes sharing her experience and tips in the form of articles and also works atprofessional CV services to help people to find their dream job. In addition, in her free time, Effie enjoys playing video games, reading, and camping.

Convert Mp4 Video To Gif Animation In Python

How do you make a GIF with Python?

Then enter the following code:.

import glob..

from PIL import Image..

def make_gif(frame_folder):.

frames = [Image. open(image) for image in glob. ... .

frame_one = frames[0].

frame_one. save("my_awesome.gif", format="GIF", append_images=frames,.

save_all=True, duration=100, loop=0).

make_gif("/path/to/images").

How do I turn a code into a GIF?

How to convert HTML to GIF.

Upload html-file(s) Select files from Computer, Google Drive, Dropbox, URL or by dragging it on the page..

Choose "to gif" Choose gif or any other format you need as a result (more than 200 formats supported).

Download your gif..

Can pygame load gifs?

This library provides functionality to load and play GIF animations in pygame. Also provided are ways to manipulate the animation playback, by setting regions to play, reversing etc.

Can we add GIF in tkinter?

The window and title commands are a part of the Tkinter library which is meant for GUI creation. Then the code orients the display and formatting of size and structure are done. A variable is chosen and a GIF is loaded onto it using the PhotoImage function.