MENU
  1. Início
  2. Python
  3. Exibição e Manipulação de Imagens com Tkinter em Python: Guia Simples

Exibição e Manipulação de Imagens com Tkinter em Python: Guia Simples

Python

Python é uma linguagem de programação poderosa utilizada em muitas áreas. Entre suas várias bibliotecas, Tkinter é a biblioteca padrão de GUI (interface gráfica do usuário) do Python, amplamente usada por iniciantes e especialistas. Este artigo explica como exibir imagens e realizar operações básicas usando o Tkinter. Vamos aprender praticando, com exemplos concretos e exercícios para você colocar a mão na massa.

Índice

Visão Geral do Tkinter

Tkinter é um kit de ferramentas GUI fornecido como parte da biblioteca padrão do Python. Funciona no Windows, macOS e Linux, ajudando a criar interfaces simples e intuitivas. As vantagens do Tkinter incluem facilidade de instalação, ampla gama de widgets e suporte da comunidade. Usando Tkinter, é fácil adicionar elementos visuais aos programas Python.

Como Instalar o Tkinter

O Tkinter é parte da biblioteca padrão do Python e geralmente é incluído automaticamente ao instalar o Python. No entanto, em alguns sistemas, pode ser necessário instalar separadamente.

Instalação no Windows

No Windows, o Tkinter é instalado automaticamente junto com o Python, sem necessidade de passos adicionais.

Instalação no macOS

No macOS, o Tkinter também é incluído na instalação do Python. No entanto, em versões mais antigas do macOS, pode ser necessário instalar o Python e o Tkinter separadamente. Nesse caso, use o comando a seguir para instalar.

brew install python-tk

Instalação no Linux

No Linux, pode ser necessário instalar o Python e o Tkinter separadamente. Use o comando abaixo para instalar.

sudo apt-get install python3-tk

Com isso, a instalação do Tkinter estará concluída. Vamos prosseguir para a criação de um programa usando Tkinter.

Preparação para Exibir Imagens

Para exibir imagens, usaremos a biblioteca Tkinter e a biblioteca de processamento de imagens Pillow (PIL). Pillow é um fork da Python Imaging Library (PIL) e é útil para abrir e manipular imagens. Siga os passos abaixo para instalar o Pillow e preparar o Tkinter para exibir imagens.

Instalação do Pillow

Primeiro, instale o Pillow. Use o comando abaixo para instalar o Pillow.

pip install pillow

Configuração Básica

O código para importar o Tkinter e o Pillow e criar uma janela básica é o seguinte:

import tkinter as tk
from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Exibição de Imagem")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image = Image.open("path/to/your/image.jpg")
photo = ImageTk.PhotoImage(image)

# Criar um widget Label para exibir a imagem
label = tk.Label(root, image=photo)
label.pack()

# Mostrar a janela
root.mainloop()

Esse código cria uma janela básica do Tkinter e exibe a imagem especificada. A seguir, explicaremos o exemplo de código em detalhes.

Exemplo de Código para Exibir Imagens

Aqui, vamos apresentar um exemplo de código para exibir uma imagem usando Tkinter e Pillow.

Exemplo Completo de Código

import tkinter as tk
from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Exibição de Imagem")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)
photo = ImageTk.PhotoImage(image)

# Criar um widget Label para exibir a imagem
label = tk.Label(root, image=photo)
label.image = photo  # Necessário para manter a referência
label.pack()

# Mostrar a janela
root.mainloop()

Explicação do Código

  • import tkinter as tk: Importa o módulo Tkinter.
  • from PIL import Image, ImageTk: Importa os módulos Image e ImageTk do Pillow.
  • root = tk.Tk(): Cria a janela principal.
  • root.title("Exibição de Imagem"): Define o título da janela.
  • root.geometry("800x600"): Configura o tamanho da janela para 800×600 pixels.
  • image_path = "path/to/your/image.jpg": Especifica o caminho do arquivo de imagem a ser exibido.
  • image = Image.open(image_path): Carrega o arquivo de imagem.
  • photo = ImageTk.PhotoImage(image): Converte a imagem para um formato compatível com o Tkinter.
  • label = tk.Label(root, image=photo): Cria um widget Label para exibir a imagem.
  • label.image = photo: Mantém a referência da imagem. Isso é necessário para evitar problemas ao exibir a imagem.
  • label.pack(): Adiciona o widget Label à janela.
  • root.mainloop(): Inicia o loop principal e exibe a janela.

Ao executar este código, a imagem especificada será exibida na janela Tkinter. A seguir, explicaremos como redimensionar imagens.

Como Redimensionar Imagens

Ao exibir imagens com Tkinter e Pillow, é possível redimensioná-las para ajustar o tamanho da janela ou atender a preferências do usuário.

Exemplo de Código para Redimensionar Imagens

O código a seguir redimensiona a imagem para um tamanho específico.

import tkinter as tk
from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Redimensionamento de Imagem")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)

# Redimensionar a imagem (exemplo: 400x300 pixels)
resized_image = image.resize((400, 300), Image.ANTIALIAS)
photo = ImageTk.PhotoImage(resized_image)

# Criar um widget Label para exibir a imagem redimensionada
label = tk.Label(root, image=photo)
label.image = photo  # Necessário para manter a referência
label.pack()

# Mostrar a janela
root.mainloop()

Explicação do Código

  • image = Image.open(image_path): Carrega o arquivo de imagem.
  • resized_image = image.resize((400, 300), Image.ANTIALIAS): Redimensiona a imagem para 400×300 pixels. O Image.ANTIALIAS é uma opção para redimensionamento de alta qualidade.
  • photo = ImageTk.PhotoImage(resized_image): Converte a imagem redimensionada para um formato compatível com o Tkinter.
  • label = tk.Label(root, image=photo): Cria um widget Label para exibir a imagem.
  • label.image = photo: Mantém a referência da imagem.
  • label.pack(): Adiciona o widget Label à janela.
  • root.mainloop(): Inicia o loop principal e exibe a janela.

Ao executar este código, a imagem será exibida redimensionada para o tamanho especificado. A seguir, explicaremos como rotacionar e inverter imagens.

Rotação e Inversão de Imagens

Além de exibir imagens, também é possível usar Tkinter e Pillow para rotacionar e inverter imagens. A seguir, vamos explicar como fazer isso com exemplos de código.

Exemplo de Código para Rotacionar Imagens

O código a seguir rotaciona a imagem em 90 graus.

import tkinter as tk
from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Rotação de Imagem")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)

# Rotacionar a imagem em 90 graus
rotated_image = image.rotate(90)
photo = ImageTk.PhotoImage(rotated_image)

# Criar um widget Label para exibir a imagem rotacionada
label = tk.Label(root, image=photo)
label.image = photo  # Necessário para manter a referência
label.pack()

# Mostrar a janela
root.mainloop()

Exemplo de Código para Inverter Imagens

A seguir, mostramos como inverter uma imagem horizontal e verticalmente.

import tkinter as tk
from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Inversão de Imagem")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)

# Inverter a imagem horizontalmente
flipped_image = image.transpose(Image.FLIP_LEFT_RIGHT)
photo = ImageTk.PhotoImage(flipped_image)

# Criar um widget Label para exibir a imagem invertida
label = tk.Label(root, image=photo)
label.image = photo  # Necessário para manter a referência
label.pack()

# Mostrar a janela
root.mainloop()

Explicação do Código

  • rotated_image = image.rotate(90): Rotaciona a imagem em 90 graus. O ângulo pode ser configurado conforme desejado.
  • flipped_image = image.transpose(Image.FLIP_LEFT_RIGHT): Inverte a imagem horizontalmente. Use Image.FLIP_TOP_BOTTOM para inverter verticalmente.
  • photo = ImageTk.PhotoImage(rotated_image) ou photo = ImageTk.PhotoImage(flipped_image): Converte a imagem para um formato compatível com o Tkinter.
  • label = tk.Label(root, image=photo): Cria um widget Label para exibir a imagem.
  • label.image = photo: Mantém a referência da imagem.
  • label.pack(): Adiciona o widget Label à janela.
  • root.mainloop(): Inicia o loop principal e exibe a janela.

Agora que você aprendeu a rotacionar e inverter imagens, vamos explicar como lidar com eventos de mouse sobre imagens.

Tratamento de Eventos de Mouse

Com o Tkinter, é possível capturar eventos de mouse sobre imagens, como cliques e arrastos, e implementar ações em resposta a esses eventos. A seguir, mostramos como fazer isso.

Tratamento de Eventos de Clique sobre Imagens

O código a seguir mostra como capturar a posição do clique e exibir um texto na posição clicada.

import tkinter as tk


from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Tratamento de Eventos de Mouse")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)
photo = ImageTk.PhotoImage(image)

# Criar um widget Canvas para exibir a imagem
canvas = tk.Canvas(root, width=800, height=600)
canvas.pack()
canvas.create_image(0, 0, anchor=tk.NW, image=photo)

# Função para tratar o evento de clique
def on_click(event):
    # Obter as coordenadas do clique
    x, y = event.x, event.y
    # Exibir o texto nas coordenadas do clique
    canvas.create_text(x, y, text=f"({x}, {y})", fill="red")

# Associar o evento de clique ao widget Canvas
canvas.bind("<Button-1>", on_click)

# Mostrar a janela
root.mainloop()

Explicação do Código

  • canvas = tk.Canvas(root, width=800, height=600): Cria um widget Canvas.
  • canvas.create_image(0, 0, anchor=tk.NW, image=photo): Exibe a imagem no Canvas.
  • def on_click(event): Define a função para tratar o evento de clique. As coordenadas do clique são obtidas com event.x e event.y.
  • canvas.create_text(x, y, text=f"({x}, {y})", fill="red"): Exibe o texto nas coordenadas do clique.
  • canvas.bind("<Button-1>", on_click): Associa o evento de clique do botão esquerdo à função on_click.

Tratamento de Eventos de Arrasto sobre Imagens

A seguir, mostramos como capturar eventos de arrasto do mouse e desenhar o trajeto percorrido.

import tkinter as tk
from PIL import Image, ImageTk

# Criar a janela principal
root = tk.Tk()
root.title("Tratamento de Eventos de Arrasto")

# Configurar o tamanho da janela
root.geometry("800x600")

# Carregar a imagem
image_path = "path/to/your/image.jpg"
image = Image.open(image_path)
photo = ImageTk.PhotoImage(image)

# Criar um widget Canvas para exibir a imagem
canvas = tk.Canvas(root, width=800, height=600)
canvas.pack()
canvas.create_image(0, 0, anchor=tk.NW, image=photo)

# Função para tratar o evento de arrasto
def on_drag(event):
    # Obter as coordenadas do arrasto
    x, y = event.x, event.y
    # Desenhar o trajeto do arrasto
    canvas.create_oval(x-2, y-2, x+2, y+2, fill="blue", outline="blue")

# Associar o evento de arrasto ao widget Canvas
canvas.bind("<B1-Motion>", on_drag)

# Mostrar a janela
root.mainloop()

Explicação do Código

  • def on_drag(event): Define a função para tratar o evento de arrasto. As coordenadas do arrasto são obtidas com event.x e event.y.
  • canvas.create_oval(x-2, y-2, x+2, y+2, fill="blue", outline="blue"): Desenha um pequeno círculo na posição do arrasto, criando o efeito de desenhar o trajeto.
  • canvas.bind("<B1-Motion>", on_drag): Associa o evento de arrasto do botão esquerdo à função on_drag.

Agora que você aprendeu a lidar com eventos de clique e arrasto sobre imagens, vamos explicar como criar um editor de imagens simples usando essas funcionalidades.

Exemplo Aplicado: Criando um Editor de Imagens

Vamos aplicar o que aprendemos para criar um editor de imagens simples. Esse editor permitirá exibir, redimensionar, rotacionar, inverter imagens e desenhar com eventos de mouse.

Exemplo Básico de Código para o Editor de Imagens

O código a seguir implementa as funcionalidades básicas do editor de imagens.

import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class ImageEditor:
    def __init__(self, root):
        self.root = root
        self.root.title("Editor de Imagens Simples")
        self.root.geometry("800x600")

        self.canvas = tk.Canvas(root, width=800, height=600)
        self.canvas.pack()

        self.menu = tk.Menu(root)
        root.config(menu=self.menu)

        file_menu = tk.Menu(self.menu)
        self.menu.add_cascade(label="Arquivo", menu=file_menu)
        file_menu.add_command(label="Abrir", command=self.open_image)
        file_menu.add_command(label="Salvar", command=self.save_image)

        edit_menu = tk.Menu(self.menu)
        self.menu.add_cascade(label="Editar", menu=edit_menu)
        edit_menu.add_command(label="Redimensionar", command=self.resize_image)
        edit_menu.add_command(label="Rotacionar", command=self.rotate_image)
        edit_menu.add_command(label="Inverter", command=self.flip_image)

        self.image = None
        self.photo = None

        self.canvas.bind("<B1-Motion>", self.paint)

    def open_image(self):
        file_path = filedialog.askopenfilename()
        if file_path:
            self.image = Image.open(file_path)
            self.photo = ImageTk.PhotoImage(self.image)
            self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)

    def save_image(self):
        file_path = filedialog.asksaveasfilename(defaultextension=".jpg")
        if file_path and self.image:
            self.image.save(file_path)

    def resize_image(self):
        if self.image:
            self.image = self.image.resize((400, 300), Image.ANTIALIAS)
            self.photo = ImageTk.PhotoImage(self.image)
            self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)

    def rotate_image(self):
        if self.image:
            self.image = self.image.rotate(90)
            self.photo = ImageTk.PhotoImage(self.image)
            self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)

    def flip_image(self):
        if self.image:
            self.image = self.image.transpose(Image.FLIP_LEFT_RIGHT)
            self.photo = ImageTk.PhotoImage(self.image)
            self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)

    def paint(self, event):
        if self.image:
            x, y = event.x, event.y
            self.canvas.create_oval(x-2, y-2, x+2, y+2, fill="blue", outline="blue")

if

 __name__ == "__main__":
    root = tk.Tk()
    app = ImageEditor(root)
    root.mainloop()

Explicação do Código

  • A classe ImageEditor contém as principais funcionalidades do editor de imagens.
  • O método __init__ configura a janela, o Canvas e o menu.
  • O método open_image abre um arquivo de imagem e o exibe no Canvas.
  • O método save_image salva a imagem atual em um arquivo.
  • O método resize_image redimensiona a imagem.
  • O método rotate_image rotaciona a imagem em 90 graus.
  • O método flip_image inverte a imagem horizontalmente.
  • O método paint trata o evento de arrasto, desenhando círculos azuis no Canvas.

Com esse editor de imagens básico, você pode adicionar funcionalidades extras para criar uma ferramenta de edição de imagens mais avançada. A seguir, propomos alguns exercícios e suas soluções para aprofundar o aprendizado.

Exercícios e Soluções

A seguir, propomos exercícios para praticar o que foi aprendido e reforçar o conhecimento sobre a exibição e manipulação de imagens com Tkinter e Pillow.

Exercício 1: Redimensionar Imagem

Adicione uma funcionalidade para redimensionar a imagem para um tamanho específico (exemplo: largura de 300 pixels e altura de 200 pixels).

Solução

Adicione o código a seguir para a funcionalidade de redimensionamento.

def resize_image(self):
    if self.image:
        self.image = self.image.resize((300, 200), Image.ANTIALIAS)
        self.photo = ImageTk.PhotoImage(self.image)
        self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)

Exercício 2: Salvar Imagem

Permita que o usuário especifique o nome do arquivo ao salvar a imagem.

Solução

Adicione o código a seguir para a funcionalidade de salvamento.

def save_image(self):
    file_path = filedialog.asksaveasfilename(defaultextension=".jpg")
    if file_path and self.image:
        self.image.save(file_path)

Exercício 3: Rotacionar Imagem em um Ângulo Específico

Adicione uma funcionalidade para rotacionar a imagem em um ângulo especificado pelo usuário (exemplo: 45 graus).

Solução

Adicione o código a seguir para a funcionalidade de rotação.

def rotate_image(self):
    if self.image:
        angle = int(input("Insira o ângulo de rotação: "))
        self.image = self.image.rotate(angle)
        self.photo = ImageTk.PhotoImage(self.image)
        self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)

Exercício 4: Exibir Múltiplas Imagens

Permita que o usuário carregue e exiba múltiplas imagens em sequência.

Solução

Adicione o código a seguir para exibir múltiplas imagens.

def open_image(self):
    file_paths = filedialog.askopenfilenames()
    if file_paths:
        for file_path in file_paths:
            self.image = Image.open(file_path)
            self.photo = ImageTk.PhotoImage(self.image)
            self.canvas.create_image(0, 0, anchor=tk.NW, image=self.photo)
            self.root.update()  # Atualizar a interface para mostrar a imagem
            self.root.after(1000)  # Mostrar cada imagem com um intervalo de 1 segundo

Exercício 5: Alterar a Cor do Desenho com o Mouse

Permita que o usuário escolha a cor ao desenhar durante o evento de arrasto do mouse.

Solução

Adicione o código a seguir para permitir a escolha da cor.

def paint(self, event):
    if self.image:
        x, y = event.x, event.y
        color = input("Insira a cor para desenhar: ")
        self.canvas.create_oval(x-2, y-2, x+2, y+2, fill=color, outline=color)

Com esses exercícios, você reforçou o aprendizado sobre a exibição e manipulação de imagens com Tkinter e Pillow. Vamos finalizar com um resumo dos principais pontos.

Resumo

Neste artigo, você aprendeu como usar a biblioteca Tkinter do Python para exibir e manipular imagens. Começamos com os fundamentos do Tkinter, passando pelo uso do Pillow para carregar, redimensionar, rotacionar, inverter imagens e tratar eventos de mouse. Criamos um editor de imagens simples para colocar em prática o que foi aprendido. Com esse conhecimento, você pode desenvolver aplicativos de processamento de imagens mais avançados. Experimente aplicar essas técnicas em diferentes projetos!

Python
Biblioteca Editor de Imagem Eventos do Mouse Exibição de Imagem Girar Inverter Manipulação de Imagem Programação Programação GUI Python Redimensionar tkinter
Índice