Mostrando postagens com marcador python. Mostrar todas as postagens
Mostrando postagens com marcador python. Mostrar todas as postagens

Integração GTK e Cairo Para Criação de Aplicação de Pintura Digital

Há algumas semanas iniciei estudos sobre como usar Python, GTK e Cairo para desenvolver aplicativos de pintura digital. Li sobre a arquitetura e o fluxo de programas como Krita, GIMP, MyPaint e Clip Studio Paint, especialmente sua interface, o modelo dos pincéis e o pipeline de renderização. Embora GTK + Cairo seja minha escolha principal, também é possível criar soluções similares com Qt (usando PySide em Python ou C++ nativo).

Para montar essa base, utilizei dois recursos fundamentais:

  1. Gtk.DrawingArea – fornece a “tela” onde tudo é desenhado e captura eventos de mouse/mesa digitalizadora.

  2. Cairo – cria e gerencia os buffers de desenho, permitindo implementar o pincel e as operações gráficas.

No Windows, instalei o MSYS2 para obter o GCC, Python, GTK, Cairo e PyGObject; depois empacotei o executável com PyInstaller. No Linux, basta usar o gerenciador de pacotes (por exemplo, apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0) para ter tudo pronto.


Introdução ao GTK + Cairo

  • GTK (GIMP Toolkit) é a biblioteca de GUI: janelas, botões, menus e áreas de desenho (Gtk.DrawingArea).

  • Cairo é a biblioteca de gráficos 2D vetoriais: linhas, formas, texto e imagens, com antialiasing e transparência, via cairo.Context.

  • Integração: sempre que a DrawingArea precisa ser redesenhada, o GTK emite o sinal "draw" e passa um contexto Cairo (cr) para sua função de callback. Você desenha no cr, e o GTK exibe o resultado.

Fluxo resumido

  1. Crie um widget Gtk.DrawingArea.

  2. Conecte o sinal "draw" ao seu método de desenho.

  3. No callback, use o cairo.Context para pintar formas, cores e texturas.

  4. Chame queue_draw() sempre que precisar atualizar a tela (por clique ou movimento).


Exemplo minimalista em Python

import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk
import cairo

class AreaDesenho(Gtk.DrawingArea):
    def __init__(self):
        super().__init__()
        self.set_size_request(400, 300)
        self.pontos = []
        self.set_events(Gdk.EventMask.BUTTON_PRESS_MASK |
                        Gdk.EventMask.POINTER_MOTION_MASK)
        self.connect("draw", self.on_draw)
        self.connect("button-press-event", self.on_press)
        self.connect("motion-notify-event", self.on_move)

    def on_draw(self, widget, cr):
        # Limpa o fundo
        cr.set_source_rgb(1, 1, 1)
        cr.paint()
        # Desenha traços
        cr.set_source_rgb(0, 0, 0)
        cr.set_line_width(2)
        for p1, p2 in zip(self.pontos, self.pontos[1:]):
            cr.move_to(*p1)
            cr.line_to(*p2)
        cr.stroke()
        return False

    def on_press(self, widget, event):
        self.pontos.append((event.x, event.y))
        self.queue_draw()

    def on_move(self, widget, event):
        if event.state & Gdk.ModifierType.BUTTON1_MASK:
            self.pontos.append((event.x, event.y))
            self.queue_draw()

class JanelaDesenho(Gtk.Window):
    def __init__(self):
        super().__init__(title="Desenho Digital")
        self.set_default_size(400, 300)
        self.connect("destroy", Gtk.main_quit)
        self.add(AreaDesenho())

JanelaDesenho().show_all()
Gtk.main()

Como funciona

  1. AreaDesenho herda de Gtk.DrawingArea e armazena pontos do mouse.

  2. No evento "draw", pinta o fundo e traça linhas entre os pontos coletados.

  3. Eventos de clique e arrasto (button-press-event e motion-notify-event) registram os pontos e solicitam redesenho com queue_draw().


Referências

Gostou deste material e do conteúdo do blog considere apoiar o desenvolvimento do mesmo visitando nossa página "Como Contribuir". Também é possível contribuir divulgando e comentando ajudando a desenvolver e melhorar o conteúdo aqui disponível. Post comumente compartilhado no mural Apoiase da minha página Dimensão Alfa
 
 
Agradece, 
 
Wandeson Ricardo  

Jornalismo & Computação




Há alguns anos me deparei com o uso da programação para raspagem de dados na internet seja por meio de APIs ou simplesmente varrendo páginas e páginas de HTML. O assunto me pareceu bem interessante e uma forma de praticar. Logo depois me deparei com uso dessas técnicas para áreas diversas e segmentos como jornalismo ou mesmo para Analise de Dados e trabalhos de pesquisa em machine learning, um ramo interessantíssimo da inteligência artificial. Assim pensei que poderia unir meu gosto pela programação com a matemática e quem sabe até a arte. 

Com a chegada de tecnologias como GPT, "generative pre-trained transformer", usado no chatGPT da openAI por exemplo bem como o "Stable Difusion" usado para geração de imagens comecei a imaginar as possibilidades e achei bem curioso o assunto. Claro que meu arcabouço ferramental técnico em matemática e computação ainda não me permitem desenvolver programas dentro destes tópicos. Considero que estes assuntos devem ser visto de forma cautelosa e mais rigorosa distante dos ruídos das grandes mídias e redes sociais para afastar-se da euforia e compreender que essas tecnologias tem suas limitações e se aplicam a problemas e situações especificas e que nem sempre entregarão os melhores resultados possíveis.

Uma das possibilidades que vi envolvendo as raspagem de dados, analise e machine learning foi acessando dados públicos do governo para analisar gastos por exemplo, como fiz para fins de estudos básicos e coloquei em meu repositório github neste link https://github.com/wsricardo/eda-tcs, onde é usados dados de contas do senado brasileiro como gastos de seus membros.
Acredito que essas tecnologias tem papel fundamental na democratização e acesso a informação provendo a população melhores recursos para tomadas de decisões quanto ao futuro de sua vida, empreendimentos e país. 

Recentemente, assim, resolvi criar um canal que usando um bot e crawler (agregador) de notícias que escrevi faz varredura em alguns portais e salva links de artigos jornalísticos para futuras consultas e os entrega em atualizações diárias em um canal do Telegram. No momento estou com mais de 1500 links de notícias salvos distribuídos em arquivos json. Acabo por usar estes quando necessito buscar algum tópico para criar meus cartuns, como o que publiquei recentemente sobre o "arcabouço fiscal". Estes projetos contudo são humildes e de fins didáticos servindo-me para estudo e ferramenta a auxiliar-me em algumas coisas.

Deixo abaixo alguns links. Outros são possíveis serem encontrados em meu Github ou aqui mesmo no blog.

Agradece ao leitor,
WSRicardo


Links

2. EDA-TCS (Acessando dados abertos sobre gastos do senado brasileiro).



News Crawler

Agregador de Notícias e Bot Telegram


Sofia - Bot criado para Telegram 
(Nome da gata de rua que adotei há alguns anos.)
A gata "Sofia"


Há um tempo atrás havia tentado escrever um crawler de notícias bem simples para capturar as principais noticias da página inicial de três grandes portais de notícias brasileiros. Havia usado a linguagem Python e o ambiente do Jupyter Lab para criar de modo interativo o código e fazendo anotações sobre o código.


Por esses dias senti vontade de voltar ao código e fiz algumas alterações no arquivo do jupyter lab e inclui pequenas funções para salvar lista dos links das notícias. Após isso isolei o código em um pequeno módulo e criei um bot para o Telegram que permitia postar as notícias das atualizações dos portais em um canal no Telegram.


O código é simples e usa módulos Python como “Resquests” e “BeaultifulSoup” para acessar as páginas e pegar o html do site extraindo assim conteúdo como titulo e link das notícias da página inicial.


Nota: O bot acima mencionado usa API do Telegram para fins didaticos e utiliza-se do módulo news-crawler que é um agregador de notícias de portais veiculos de comunicação e jornalismo sérios. Assim o mesmo dentro da leis nacionais e normas da plataforma não serve-se e nem propõe-se para divulgação de notícias falsas (fake news) .

Deixo abaixo o link para o código no Github.

www.github.com/wsricardo/news-crawler


Para saber como apoiar este blog visite a página "Apoie"

Agradece,

Wandeson Ricardo




Viagem pelo Mundo LISP #1


 Lisp é uma família linguagens de programação que se encaixa no paradigma funcional tendo surgido por volta da década de 50 com John McCarthy tendo padrão Common Lisp estabelecido na década de 80 e possuindo vários dialetos. 

Uma possibilidade para rodar códigos em lisp, em particular o Common Lisp, é através do compilador de lisp SBCL ou com CLisp. Em ambientes Linux é possível usar o Emacs para editar os códigos lisp com SBCL e Slime. No Windows é possível usar a combinação Emacs, SBCL, Slime e Quicklisp através do Portacle.

 

Sintaxe

Uma das características comuns da linguagem Lisp é o uso de parênteses e o fato de operadores antecederem operandos em uma notação conhecida como prefixa.

Exemplo (no dialeto "common lisp") abaixo calcula o fatorial de um número $ n \in \mathbb{N} $ definido como $ n! = n \times (n - 1) \times ( n - 2) \times \cdots \times 2 \times 1 $ com $ 0! = 1 $.

( defun fat ( n )
    ( if ( = n 1 )
        1
        ( * ( fat ( - n 1 ) ) n )
    )
)

Deixo algumas dicas de sites sobre a linguagem Lisp como o site https://lisp-lang.org/ com referências sobre a linguagem.   Algumas implementações lisp:

Usuários Windows podem considerar usar o Portacle que combina o uso do EMacs, SLime, SBCL e Quicklisp (gestor de packages lisp) https://portacle.github.io/

 

GUI

Para criação de interfaces gráficas há possibilidade de usar a biblioteca IUP conforme pode ser visto neste link https://github.com/lispnik/iup.


Livros 

 

Lisp em Python

LisPy Implementação de Lisp com a linguagem Python  https://norvig.com/lispy.html. Texto e vídeo do Ramalho detalhando implementação,

"O Lisp de Norvig" por Ramalho

Detalhes e explicações de implementação do interpretador de Lisp em Python com Ramalho, em uma Live para o canal do Eduardo Mendes (Dunossauro) abaixo.