Wycinanie tła z obrazów to popularny problem w fotografii, grafice komputerowej czy mediach społecznościowych. Python oferuje narzędzia, dzięki którym możemy łatwo stworzyć aplikację do tego celu, wykorzystując potęgę sztucznej inteligencji i przetwarzania obrazów. W tym poradniku pokażemy krok po kroku, jak napisać aplikację usuwającą tło z obrazów.

Wprowadzenie do technologii

Do stworzenia naszej aplikacji użyjemy następujących narzędzi:

• Python: Uniwersalny i łatwy w nauce język programowania, idealny do szybkiego prototypowania i analizy danych. Python oferuje bogaty ekosystem bibliotek do przetwarzania obrazów i uczenia maszynowego.
• OpenCV: Biblioteka do przetwarzania obrazów i wideo. Jest przydatna do operacji takich jak zmiana rozmiaru, filtrowanie czy konwersje kolorów.
• Rembg: Narzędzie oparte na modelu U-2-Net, wykorzystujące sztuczną inteligencję do precyzyjnego wycinania tła z obrazów.
• Pillow: Biblioteka do przetwarzania obrazów w Pythonie, wspierająca formaty takie jak JPEG, PNG czy GIF.
• Gradio: Framework pozwalający szybko tworzyć prosty interfejs użytkownika dla aplikacji machine learning i innych narzędzi.

Przygotowanie projektu

1. Zainstaluj Python

Upewnij się, że Python jest zainstalowany na twoim komputerze. Najnowszą wersję możesz pobrać z oficjalnej strony https://www.python.org

Podczas instalacji zaznacz opcję Add Python to PATH, aby Python był dostępny w wierszu poleceń.

Ważne:

Pobierz wersję =<3.12, aby była kompatybilna z bibliotekami, z których będziemy korzystać.

2. Czym jest wirtualne środowisko?

Wirtualne środowisko (ang. virtual environment) to izolowane środowisko dla Pythona, w którym możemy instalować specyficzne biblioteki dla danego projektu. W ten sposób unikamy konfliktów między różnymi projektami, które mogą wymagać innych wersji tych samych bibliotek.

Na przykład: projekt A może korzystać z OpenCV w wersji 4.5, podczas gdy projekt B wymaga wersji 4.7. Bez wirtualnych środowisk musiałbyś ręcznie zarządzać bibliotekami globalnie, co prowadzi do problemów z kompatybilnością.

3. Tworzenie wirtualnego środowiska

Aby utworzyć wirtualne środowisko w folderze projektu, wykonaj w terminalu:

python -m venv venv

• python: Wywołuje interpretera Pythona.
• -m venv: Uruchamia moduł do tworzenia wirtualnych środowisk.
• venv: To nazwa folderu, w którym zostaną zapisane wszystkie pliki wirtualnego środowiska. Możesz nadać mu inną nazwę, np. env.

Po wykonaniu tego polecenia w folderze projektu pojawi się katalog venv, zawierający:

• Scripts (Windows) lub bin (Linux/macOS): Pliki do aktywacji środowiska.
• Lib: Zainstalowane biblioteki Pythona.
• pyvenv.cfg: Plik konfiguracyjny.

4. Aktywacja wirtualnego środowiska

Aby aktywować wirtualne środowisko, wykonaj:

• Windows:

.\venv\Scripts\activate

Po aktywacji w terminalu pojawi się prefiks (venv), co oznacza, że pracujesz w izolowanym środowisku.

• macOS/Linux:

source venv/bin/activate

5. Wyłączenie wirtualnego środowiska

Aby zakończyć pracę w wirtualnym środowisku, użyj polecenia:

deactivate

6. Przełączanie między wirtualnymi środowiskami

Jeśli pracujesz nad kilkoma projektami, każde może mieć swoje własne środowisko. Wystarczy aktywować odpowiednie środowisko, uruchamiając plik aktywacyjny w folderze danego projektu.

Instalacja bibliotek

Zainstalujmy wymagane biblioteki, używając polecenia pip w aktywnym środowisku wirtualnym:

pip install opencv-python rembg numpy pillow gradio onnxruntime

Opis bibliotek:

• OpenCV: Służy do podstawowego przetwarzania obrazów, np. zmiany rozmiaru, wykrywania krawędzi czy konwersji kolorów.
• Rembg: Wykorzystuje model AI do automatycznego usuwania tła z obrazów. Obsługuje formaty takie jak PNG (zachowując przezroczystość).
• NumPy: Biblioteka do obliczeń numerycznych, często używana w kontekście przetwarzania obrazu.
• Pillow: Prosta biblioteka do edycji obrazów.
• Gradio: Narzędzie do szybkiego tworzenia interfejsów użytkownika dla aplikacji webowych.

Tworzenie aplikacji

1. Importowanie bibliotek

Zacznijmy od zaimportowania wszystkich potrzebnych modułów.

import cv2
import numpy as np
from rembg import remove
from PIL import Image
import gradio as gr

2. Funkcja do wycinania tła

Stworzymy funkcję, która będzie odpowiedzialna za przetwarzanie obrazu i usuwanie jego tła.

def remove_background(input_image):
    # Konwersja obrazu z formatu NumPy na PIL
    input_image = Image.fromarray(input_image)

    # Konwersja PIL na BytesIO (w formacie, który rembg oczekuje)
    img_byte_arr = io.BytesIO()
    input_image.save(img_byte_arr, format='PNG')
    img_byte_arr = img_byte_arr.getvalue()

    # Usuwanie tła za pomocą rembg
    output_image = remove(img_byte_arr)

    # Konwersja obrazu wynikowego z BytesIO do NumPy
    output_image = Image.open(io.BytesIO(output_image))
    output_image = np.array(output_image)

    return output_image

3. Tworzenie interfejsu

Dzięki Gradio stworzymy intuicyjny interfejs użytkownika. Użytkownik będzie mógł przesłać obraz i zobaczyć wynik z usuniętym tłem w czasie rzeczywistym.

def create_interface():
    interface = gr.Interface(
        fn=remove_background,
        inputs=gr.Image(type="numpy"),
        outputs=gr.Image(type="numpy"),
        title="Usuwanie Tła z Obrazu",
        description="Prześlij obraz, aby usunąć jego tło."
    )
    return interface

if __name__ == "__main__":
    app = create_interface()
    app.launch(share=True)  # Uruchomienie aplikacji z możliwością udostępnienia

4. Kompletny kod

import cv2
import numpy as np
from rembg import remove
from PIL import Image
import gradio as gr
import io

def remove_background(input_image):
    # Konwersja obrazu z formatu NumPy na PIL
    input_image = Image.fromarray(input_image)

    # Konwersja PIL na BytesIO (w formacie, który rembg oczekuje)
    img_byte_arr = io.BytesIO()
    input_image.save(img_byte_arr, format='PNG')
    img_byte_arr = img_byte_arr.getvalue()

    # Usuwanie tła za pomocą rembg
    output_image = remove(img_byte_arr)

    # Konwersja obrazu wynikowego z BytesIO do NumPy
    output_image = Image.open(io.BytesIO(output_image))
    output_image = np.array(output_image)

    return output_image

def create_interface():
    interface = gr.Interface(
        fn=remove_background,
        inputs=gr.Image(type="numpy"),
        outputs=gr.Image(type="numpy"),
        title="Usuwanie Tła z Obrazu",
        description="Prześlij obraz, aby usunąć jego tło."
    )
    return interface

if __name__ == "__main__":
    app = create_interface()
    app.launch(share=True)  # Uruchomienie aplikacji z możliwością udostępnienia

Zapisz plik jako app.py w folderze projektu, a następnie uruchom

python app.py

Ważne aby być w konsoli w sesji wirtualnego środowiska.

Komenda ta wyświetli komunikat o aktywnym serwerze. Skopiuj jego adres do przeglądarki.

Twoim oczom powinien ukazać się interfejs aplikacji.

* Running on local URL:  http://127.0.0.1:7860

Wyniki:

Podsumowanie

W tym artykule stworzyliśmy prostą aplikację w Pythonie do usuwania tła z obrazów. Wykorzystaliśmy bibliotekę Rembg do analizy obrazu i OpenCV z Pillow do przetwarzania danych wizualnych. Dzięki Gradio przygotowaliśmy prosty interfejs użytkownika, który umożliwia łatwe korzystanie z naszej aplikacji.

Gotową aplikację możesz rozbudować, np. o opcje tworzenia maski, która będzie służyła do oznaczenia głównego obiektu. Powodzenia w dalszych eksperymentach z Pythonem i grafiką komputerową!