imgboost-ai 0.1.0__py3-none-any.whl

imgboost/utils/image_io.py

@@ -0,0 +1,231 @@
+import cv2
+import numpy as np
+from PIL import Image
+from pathlib import Path
+
+
+class ImageIO:
+    """
+    Utilitários para carregar e salvar imagens.
+    """
+    
+    SUPPORTED_FORMATS = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.tif', '.webp'}
+    
+    def __init__(self):
+        pass
+    
+    def load(self, path):
+        """
+        Carrega uma imagem de arquivo.
+        
+        Args:
+            path: Caminho do arquivo
+            
+        Returns:
+            Imagem BGR ou None se falhar
+        """
+        path = Path(path)
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Arquivo não encontrado: {path}")
+        
+        if path.suffix.lower() not in self.SUPPORTED_FORMATS:
+            raise ValueError(f"Formato não suportado: {path.suffix}")
+        
+        # Tentar carregar com OpenCV primeiro
+        img = cv2.imread(str(path), cv2.IMREAD_COLOR)
+        
+        if img is None:
+            # Fallback para PIL
+            try:
+                pil_img = Image.open(path)
+                img = np.array(pil_img)
+                
+                # Converter RGB para BGR se necessário
+                if len(img.shape) == 3 and img.shape[2] == 3:
+                    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+                elif len(img.shape) == 3 and img.shape[2] == 4:
+                    # RGBA para BGR
+                    img = cv2.cvtColor(img, cv2.COLOR_RGBA2BGR)
+                    
+            except Exception as e:
+                raise IOError(f"Erro ao carregar imagem: {e}")
+        
+        return img
+    
+    def save(self, img, path, quality=95):
+        """
+        Salva uma imagem em arquivo.
+        
+        Args:
+            img: Imagem BGR
+            path: Caminho de destino
+            quality: Qualidade JPEG (1-100)
+        """
+        path = Path(path)
+        
+        # Criar diretório se não existir
+        path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Parâmetros de salvamento
+        params = []
+        
+        if path.suffix.lower() in {'.jpg', '.jpeg'}:
+            # JPEG
+            params = [cv2.IMWRITE_JPEG_QUALITY, quality]
+        elif path.suffix.lower() == '.png':
+            # PNG - comprimir mas manter qualidade
+            compression = int((100 - quality) / 10)
+            params = [cv2.IMWRITE_PNG_COMPRESSION, min(compression, 9)]
+        elif path.suffix.lower() == '.webp':
+            # WebP
+            params = [cv2.IMWRITE_WEBP_QUALITY, quality]
+        
+        # Salvar
+        success = cv2.imwrite(str(path), img, params)
+        
+        if not success:
+            raise IOError(f"Erro ao salvar imagem: {path}")
+    
+    def load_batch(self, directory, pattern='*'):
+        """
+        Carrega múltiplas imagens de um diretório.
+        
+        Args:
+            directory: Diretório de origem
+            pattern: Padrão de busca (ex: '*.jpg')
+            
+        Returns:
+            Lista de tuplas (path, imagem)
+        """
+        directory = Path(directory)
+        
+        if not directory.is_dir():
+            raise NotADirectoryError(f"Não é um diretório: {directory}")
+        
+        images = []
+        
+        for file_path in directory.glob(pattern):
+            if file_path.suffix.lower() in self.SUPPORTED_FORMATS:
+                try:
+                    img = self.load(file_path)
+                    if img is not None:
+                        images.append((str(file_path), img))
+                except Exception as e:
+                    print(f"Erro ao carregar {file_path}: {e}")
+        
+        return images
+    
+    def get_image_info(self, path):
+        """
+        Obtém informações sobre uma imagem sem carregar completamente.
+        
+        Args:
+            path: Caminho da imagem
+            
+        Returns:
+            Dicionário com informações
+        """
+        path = Path(path)
+        
+        if not path.exists():
+            raise FileNotFoundError(f"Arquivo não encontrado: {path}")
+        
+        try:
+            pil_img = Image.open(path)
+            
+            info = {
+                'format': pil_img.format,
+                'mode': pil_img.mode,
+                'width': pil_img.width,
+                'height': pil_img.height,
+                'size_mb': path.stat().st_size / (1024 * 1024),
+                'path': str(path),
+            }
+            
+            # Calcular megapixels
+            info['megapixels'] = (pil_img.width * pil_img.height) / 1_000_000
+            
+            pil_img.close()
+            
+            return info
+            
+        except Exception as e:
+            raise IOError(f"Erro ao ler informações: {e}")
+    
+    def convert_format(self, input_path, output_path, quality=95):
+        """
+        Converte formato de imagem.
+        
+        Args:
+            input_path: Caminho de entrada
+            output_path: Caminho de saída
+            quality: Qualidade (para formatos com perda)
+        """
+        img = self.load(input_path)
+        self.save(img, output_path, quality=quality)
+    
+    def validate_image(self, path):
+        """
+        Valida se o arquivo é uma imagem válida.
+        
+        Args:
+            path: Caminho do arquivo
+            
+        Returns:
+            True se válido, False caso contrário
+        """
+        try:
+            path = Path(path)
+            
+            if not path.exists():
+                return False
+            
+            if path.suffix.lower() not in self.SUPPORTED_FORMATS:
+                return False
+            
+            # Tentar abrir
+            img = cv2.imread(str(path))
+            
+            if img is None:
+                pil_img = Image.open(path)
+                pil_img.verify()
+                pil_img.close()
+            
+            return True
+            
+        except Exception:
+            return False
+    
+    def resize_if_needed(self, img, max_size=4096):
+        """
+        Redimensiona imagem se exceder tamanho máximo.
+        
+        Args:
+            img: Imagem BGR
+            max_size: Dimensão máxima permitida
+            
+        Returns:
+            Imagem redimensionada se necessário
+        """
+        height, width = img.shape[:2]
+        
+        if max(height, width) <= max_size:
+            return img
+        
+        # Calcular nova dimensão
+        if height > width:
+            new_height = max_size
+            new_width = int(width * (max_size / height))
+        else:
+            new_width = max_size
+            new_height = int(height * (max_size / width))
+        
+        # Redimensionar
+        resized = cv2.resize(
+            img,
+            (new_width, new_height),
+            interpolation=cv2.INTER_AREA
+        )
+        
+        return resized

imgboost_ai-0.1.0.dist-info/METADATA

@@ -0,0 +1,387 @@
+Metadata-Version: 2.4
+Name: imgboost-ai
+Version: 0.1.0
+Summary: Melhore a qualidade de imagens com IA - Processamento avançado para documentos, screenshots e fotos
+Home-page: https://github.com/yourusername/imgboost
+Author: ImgBoost Team
+Author-email: João Pedro Silva <jpedrops092@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/JPEDROPS092/imgboost
+Project-URL: Documentation, https://github.com/JPEDROPS092/imgboost#readme
+Project-URL: Repository, https://github.com/JPEDROPS092/imgboost
+Project-URL: Issues, https://github.com/JPEDROPS092/imgboost/issues
+Keywords: image,processing,ai,enhancement,super-resolution,ocr,document
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: opencv-python>=4.8.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: scikit-image>=0.21.0
+Requires-Dist: tqdm>=4.65.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# 🚀 ImgBoost
+
+Biblioteca CLI profissional para melhorar qualidade de imagens usando IA e técnicas avançadas de processamento.
+
+![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+## ✨ Características
+
+- 🎯 **4 Modos especializados** de processamento
+- 🔧 **Denoise inteligente** com OpenCV
+- 📈 **CLAHE** para melhoria de contraste adaptativo
+- ✂️ **Sharpening** profissional
+- 🌙 **Modo Dark UI** otimizado para interfaces escuras
+- 📄 **Modo Texto/OCR** para documentos
+- 🚀 **Super-resolução** com upscaling de alta qualidade
+- ⚡ **Processamento em lote** com suporte a paralelização
+- 💾 **Múltiplos formatos** (PNG, JPG, BMP, TIFF, WebP)
+
+## 📦 Instalação
+
+```bash
+# Clone o repositório
+git clone https://github.com/jpedrops092/imgboost.git
+cd imgboost
+
+# Instale em modo desenvolvimento
+pip install -e .
+
+# Ou instale as dependências manualmente
+pip install -r requirements.txt
+```
+
+### Dependências
+
+- Python >= 3.8
+- OpenCV >= 4.8.0
+- NumPy >= 1.24.0
+- Click >= 8.1.0
+- scikit-image >= 0.21.0
+- tqdm >= 4.66.0
+- PyTorch >= 2.0.0 (opcional, para super-resolução com IA)
+
+## 🎯 Uso Rápido
+
+### Modo Geral (melhoria padrão)
+
+```bash
+imgboost process foto.jpg
+```
+
+### Modo Texto/Documento (OCR)
+
+```bash
+imgboost process documento.png --mode text
+```
+
+### Modo Dark UI (WhatsApp, interfaces escuras)
+
+```bash
+imgboost process screenshot_whatsapp.png --mode dark
+```
+
+### Super-resolução (upscale 2x)
+
+```bash
+imgboost process imagem_baixa_res.jpg --mode superres
+# Ou adicionar upscale a qualquer modo:
+imgboost process foto.jpg --mode general --upscale
+```
+
+### Processar diretório inteiro
+
+```bash
+imgboost process ./minhas_fotos --mode general --output ./melhoradas
+```
+
+### Processamento em lote (paralelo)
+
+```bash
+imgboost batch ./minhas_fotos --workers 8
+```
+
+## 📋 Modos de Processamento
+
+### 1. **General** (Padrão)
+Melhoria geral balanceada:
+- Denoise (redução de ruído)
+- CLAHE (contraste adaptativo)
+- Sharpening (nitidez)
+
+**Ideal para:** Fotos gerais, prints, screenshots
+
+### 2. **Text** (Texto/Documento)
+Otimizado para leitura e OCR:
+- Denoise focado
+- Binarização adaptativa
+- Deskew (correção de inclinação)
+- Remoção de sombras
+
+**Ideal para:** Documentos escaneados, fotos de papel, notas
+
+### 3. **Dark** (Interfaces Escuras)
+Otimizado para UIs com fundo escuro:
+- Ajuste de gamma
+- CLAHE agressivo
+- Denoise seletivo
+- Realce de texto em fundos escuros
+
+**Ideal para:** WhatsApp Dark, apps com tema escuro, capturas noturnas
+
+### 4. **Superres** (Super-resolução)
+Upscaling com preservação de qualidade:
+- Denoise pré-processamento
+- Upscale 2x com LANCZOS4
+- Unsharp mask pós-processamento
+- Realce de textura
+
+**Ideal para:** Imagens de baixa resolução, ampliação para impressão
+
+## ⚙️ Opções Avançadas
+
+```bash
+imgboost process imagem.jpg \
+  --mode general \
+  --output ./output \
+  --upscale \
+  --quality 95 \
+  --format png \
+  --denoise-strength 15 \
+  --contrast 4.0 \
+  --sharpen \
+  --verbose
+```
+
+### Parâmetros
+
+- `--output, -o`: Pasta de saída (padrão: `output`)
+- `--mode, -m`: Modo de processamento (`general`, `text`, `dark`, `superres`)
+- `--upscale, -u`: Aplicar super-resolução 2x
+- `--quality, -q`: Qualidade JPEG 1-100 (padrão: 95)
+- `--format, -f`: Formato de saída (`auto`, `png`, `jpg`)
+- `--denoise-strength, -d`: Força do denoise 0-30 (padrão: 10)
+- `--contrast, -c`: Intensidade CLAHE 1.0-5.0 (padrão: 3.0)
+- `--sharpen, -s`: Aplicar sharpening extra
+- `--verbose, -v`: Modo verboso
+
+## 📊 Exemplos Práticos
+
+### Melhorar print de WhatsApp escuro
+
+```bash
+imgboost process whatsapp_dark.png --mode dark --sharpen --quality 100
+```
+
+### Preparar documento para OCR
+
+```bash
+imgboost process documento_foto.jpg --mode text --format png --output ./ocr
+```
+
+### Upscale de imagem para impressão
+
+```bash
+imgboost process logo_pequeno.png --mode superres --quality 100 --format png
+```
+
+### Processar pasta de fotos antigas
+
+```bash
+imgboost process ./fotos_antigas --mode general --upscale --denoise-strength 20
+```
+
+### Lote em paralelo (rápido)
+
+```bash
+imgboost batch ./muitas_fotos --workers 8
+```
+
+## 🔧 Uso Programático
+
+Você também pode usar o ImgBoost como biblioteca Python:
+
+```python
+from imgboost import Engine
+
+# Criar engine
+engine = Engine(
+    output_dir='output',
+    quality=95,
+    denoise_strength=10,
+    contrast_clip=3.0
+)
+
+# Processar imagem
+output_path = engine.run(
+    'input.jpg',
+    mode='general',
+    upscale=True
+)
+
+print(f"Imagem salva em: {output_path}")
+```
+
+### Processamento customizado
+
+```python
+from imgboost.processors import ImageFilters, SuperResolution
+from imgboost.utils import ImageIO
+
+# Carregar
+io = ImageIO()
+img = io.load('input.jpg')
+
+# Processar
+filters = ImageFilters(denoise_strength=15)
+img = filters.denoise(img)
+img = filters.enhance_contrast(img)
+img = filters.sharpen(img)
+
+# Upscale
+sr = SuperResolution()
+img = sr.upscale(img, scale=2)
+
+# Salvar
+io.save(img, 'output.jpg', quality=95)
+```
+
+## 📚 Informações do Sistema
+
+```bash
+imgboost info
+```
+
+Mostra:
+- Versão do ImgBoost
+- Versões das dependências
+- Disponibilidade de CUDA
+- Modos disponíveis
+
+## 🛠️ Desenvolvimento
+
+### Estrutura do Projeto
+
+```
+imgboost/
+├── imgboost/
+│   ├── __init__.py
+│   ├── cli.py              # Interface CLI
+│   ├── core.py             # Engine principal
+│   ├── processors/
+│   │   ├── filters.py      # Filtros OpenCV
+│   │   ├── document.py     # Processamento de documentos
+│   │   └── superres.py     # Super-resolução
+│   └── utils/
+│       └── image_io.py     # I/O de imagens
+├── setup.py
+├── requirements.txt
+└── README.md
+```
+
+### Adicionar novos processadores
+
+1. Crie um arquivo em `imgboost/processors/`
+2. Implemente sua classe de processamento
+3. Importe em `imgboost/processors/__init__.py`
+4. Use no `core.py`
+
+### Executar testes
+
+```bash
+# Teste básico
+imgboost process test_image.jpg --verbose
+
+# Teste de lote
+imgboost batch test_images/ --workers 4
+```
+
+## 🎓 Técnicas Implementadas
+
+### Denoise
+- **Fast Non-Local Means**: Preserva bordas enquanto remove ruído
+- Força ajustável (0-30)
+
+### Contraste
+- **CLAHE**: Histogram equalization adaptativo
+- Evita sobre-saturação
+- Tile grid 8x8
+
+### Sharpening
+- **Unsharp Mask**: Sharpening profissional
+- **Kernel customizado**: Controle de intensidade
+- Preserva naturalidade
+
+### Super-resolução
+- **LANCZOS4**: Interpolação de alta qualidade
+- **Multi-scale**: Preservação de detalhes
+- **Texture enhancement**: Realce de texturas
+
+### Processamento de Documentos
+- **Adaptive Thresholding**: Binarização inteligente
+- **Deskew**: Correção de inclinação
+- **Shadow removal**: Remoção de sombras
+- **Morphological operations**: Limpeza de ruído
+
+## 🚀 Próximos Passos
+
+- [ ] Integração com Real-ESRGAN para super-resolução com IA
+- [ ] Suporte a vídeos
+- [ ] Processamento de PDFs
+- [ ] Interface web
+- [ ] Presets customizáveis
+- [ ] Batch processing com GPU
+- [ ] Plugin para Photoshop/GIMP
+
+## 📄 Licença
+
+MIT License - veja LICENSE para detalhes
+
+## 🤝 Contribuindo
+
+Contribuições são bem-vindas! Por favor:
+
+1. Fork o projeto
+2. Crie uma branch para sua feature (`git checkout -b feature/AmazingFeature`)
+3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
+4. Push para a branch (`git push origin feature/AmazingFeature`)
+5. Abra um Pull Request
+
+## 📧 Suporte
+
+- 🐛 **Issues**: [GitHub Issues](https://github.com/jpedrops092/imgboost/issues)
+- 💬 **Discussões**: [GitHub Discussions](https://github.com/jpedrops092/imgboost/discussions)
+
+## 🌟 Agradecimentos
+
+- OpenCV pela biblioteca de processamento de imagens
+- Real-ESRGAN pela inspiração em super-resolução
+- Click pela excelente biblioteca CLI
+
+---
+
+Feito com ❤️ por ImgBoost Team

imgboost_ai-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+imgboost/__init__.py,sha256=f7asSpI1tSmnODKo-1a8AyZt0vjVk3FBZ_cquTbUkas,169
+imgboost/cli.py,sha256=0F8R7MUJ4S_Yo9RrD-a0uIDoGrNS5wNZlvWwPtIYx6M,6285
+imgboost/core.py,sha256=KCj-m5qfQE39qdvis-Y-BLR6YQkZ3_NxaIA-cMURJUQ,5510
+imgboost/processors/__init__.py,sha256=C1dcg4ies5KA2xwnZaT827WoNoEK69JrUXCjf2oS2B4,234
+imgboost/processors/document.py,sha256=_vSaNVZ1ICzFfsb_b2qddtLtnCJ9e_DPyNE8FVTBkbU,7739
+imgboost/processors/filters.py,sha256=TVgAy0b6SI3xmQRjcMrw2fnIm4hvS4WDO5d6kehXY3Q,7332
+imgboost/processors/superres.py,sha256=-dtuURGM2Q8GC0oSAm8c5UJ6Za_gfyjMnHO6qRoXKOg,7697
+imgboost/utils/__init__.py,sha256=9PDSxEq549702TVbUMtAgI_98NbGz2Ftal1SDtABfqw,94
+imgboost/utils/image_io.py,sha256=Io_xTJ8yiJJgPCRgn0QwGqAVBpfXHgZpvoVGHzmLqKM,6787
+imgboost_ai-0.1.0.dist-info/licenses/LICENSE,sha256=xWKsKcIRX-JUGCEHuGB-VwHNPyDB6EdKqzXeZ29W__M,1070
+imgboost_ai-0.1.0.dist-info/METADATA,sha256=y2VqESvc9DZPMj6vniIPIUWBstHZHxdHKI5DAbWNqWw,10135
+imgboost_ai-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+imgboost_ai-0.1.0.dist-info/entry_points.txt,sha256=TZcqC8QOrXU1GBHnHQrTsOm4_I78DMPYiUwgQ6AxRng,46
+imgboost_ai-0.1.0.dist-info/top_level.txt,sha256=SBl9I-TbzqywBCI8IdcZ8FRtHBZqmMoAVaK_syFJ87c,9
+imgboost_ai-0.1.0.dist-info/RECORD,,

imgboost_ai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

imgboost_ai-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imgboost = imgboost.cli:cli

imgboost_ai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ImgBoost Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

imgboost_ai-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+imgboost