imgboost-ai 0.1.0__py3-none-any.whl

imgboost/__init__.py

@@ -0,0 +1,10 @@
+"""
+ImgBoost - Biblioteca CLI para melhorar qualidade de imagens
+"""
+
+__version__ = '0.1.0'
+__author__ = 'ImgBoost Team'
+
+from .core import Engine
+
+__all__ = ['Engine']

imgboost/cli.py

@@ -0,0 +1,169 @@
+import click
+import os
+from pathlib import Path
+from .core import Engine
+
+
+@click.group()
+@click.version_option(version='0.1.0')
+def cli():
+    """
+    🚀 ImgBoost - Melhore a qualidade de imagens via CLI
+    
+    Modos disponíveis:
+    - general: Melhoria geral (denoise + contrast + sharpen)
+    - text: Otimizado para documentos e texto
+    - dark: Otimizado para interfaces escuras (WhatsApp, etc)
+    - superres: Super-resolução com IA (upscale 2x)
+    """
+    pass
+
+
+@cli.command()
+@click.argument('input_path', type=click.Path(exists=True))
+@click.option('--output', '-o', default='output', help='Pasta de saída para imagens processadas.')
+@click.option('--mode', '-m', 
+              type=click.Choice(['general', 'text', 'dark', 'superres'], case_sensitive=False), 
+              default='general', 
+              help='Modo de processamento.')
+@click.option('--upscale', '-u', is_flag=True, help='Aplicar Super-Resolução com IA (2x).')
+@click.option('--quality', '-q', type=int, default=95, help='Qualidade JPEG de saída (1-100).')
+@click.option('--format', '-f', type=click.Choice(['auto', 'png', 'jpg', 'jpeg']), 
+              default='auto', help='Formato de saída.')
+@click.option('--denoise-strength', '-d', type=int, default=10, help='Força do denoise (0-30).')
+@click.option('--contrast', '-c', type=float, default=3.0, help='Intensidade do CLAHE (1.0-5.0).')
+@click.option('--sharpen', '-s', is_flag=True, help='Aplicar sharpening extra.')
+@click.option('--verbose', '-v', is_flag=True, help='Mostrar informações detalhadas.')
+def process(input_path, output, mode, upscale, quality, format, denoise_strength, 
+            contrast, sharpen, verbose):
+    """
+    Processar uma imagem ou diretório inteiro.
+    
+    Exemplos:
+    
+        imgboost process foto.jpg --mode text
+        
+        imgboost process ./fotos --mode dark --upscale
+        
+        imgboost process documento.png -m text -o melhorado
+    """
+    # Criar engine com configurações
+    engine = Engine(
+        output_dir=output,
+        quality=quality,
+        output_format=format,
+        denoise_strength=denoise_strength,
+        contrast_clip=contrast,
+        extra_sharpen=sharpen,
+        verbose=verbose
+    )
+    
+    # Verificar se é diretório ou arquivo único
+    input_path = Path(input_path)
+    
+    if input_path.is_dir():
+        # Processar todos os arquivos de imagem no diretório
+        image_extensions = {'.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.webp'}
+        files = [f for f in input_path.iterdir() 
+                if f.suffix.lower() in image_extensions]
+        
+        if not files:
+            click.echo("❌ Nenhuma imagem encontrada no diretório.", err=True)
+            return
+        
+        click.echo(f"📂 Encontradas {len(files)} imagens para processar\n")
+        
+        with click.progressbar(files, 
+                             label='🔧 Processando imagens',
+                             show_eta=True) as bar:
+            for file in bar:
+                try:
+                    engine.run(str(file), mode, upscale)
+                except Exception as e:
+                    if verbose:
+                        click.echo(f"\n❌ Erro em {file.name}: {e}", err=True)
+        
+        click.echo(f"\n✅ Processamento concluído! Imagens salvas em: {output}/")
+        
+    else:
+        # Processar arquivo único
+        if verbose:
+            click.echo(f"🚀 Processando: {input_path.name}")
+            click.echo(f"📋 Modo: {mode}")
+            click.echo(f"🎯 Super-resolução: {'Sim' if upscale else 'Não'}\n")
+        
+        try:
+            output_path = engine.run(str(input_path), mode, upscale)
+            click.echo(f"✅ Imagem processada com sucesso!")
+            click.echo(f"💾 Salva em: {output_path}")
+        except Exception as e:
+            click.echo(f"❌ Erro ao processar: {e}", err=True)
+
+
+@cli.command()
+@click.argument('input_path', type=click.Path(exists=True))
+@click.option('--output', '-o', default='output_batch', help='Pasta de saída.')
+@click.option('--workers', '-w', type=int, default=4, help='Número de processos paralelos.')
+def batch(input_path, output, workers):
+    """
+    Processar múltiplas imagens em paralelo (mais rápido).
+    
+    Exemplo:
+        imgboost batch ./fotos --workers 8
+    """
+    from concurrent.futures import ProcessPoolExecutor
+    from functools import partial
+    
+    input_path = Path(input_path)
+    
+    if not input_path.is_dir():
+        click.echo("❌ O caminho deve ser um diretório.", err=True)
+        return
+    
+    image_extensions = {'.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.webp'}
+    files = [str(f) for f in input_path.iterdir() 
+            if f.suffix.lower() in image_extensions]
+    
+    if not files:
+        click.echo("❌ Nenhuma imagem encontrada.", err=True)
+        return
+    
+    click.echo(f"📂 {len(files)} imagens encontradas")
+    click.echo(f"⚙️  Usando {workers} workers\n")
+    
+    engine = Engine(output_dir=output)
+    process_func = partial(engine.run, mode='general', upscale=False)
+    
+    with ProcessPoolExecutor(max_workers=workers) as executor:
+        results = list(tqdm(
+            executor.map(process_func, files),
+            total=len(files),
+            desc="Processando"
+        ))
+    
+    click.echo(f"\n✅ Processamento em lote concluído!")
+
+
+@cli.command()
+def info():
+    """Mostrar informações sobre a biblioteca e dependências."""
+    import cv2
+    import numpy as np
+    import torch
+    
+    click.echo("📦 ImgBoost v0.1.0")
+    click.echo("\n🔧 Dependências:")
+    click.echo(f"  • OpenCV: {cv2.__version__}")
+    click.echo(f"  • NumPy: {np.__version__}")
+    click.echo(f"  • PyTorch: {torch.__version__}")
+    click.echo(f"  • CUDA disponível: {'Sim ✅' if torch.cuda.is_available() else 'Não ❌'}")
+    click.echo("\n📚 Modos disponíveis:")
+    click.echo("  • general   - Melhoria geral de qualidade")
+    click.echo("  • text      - Otimizado para documentos e OCR")
+    click.echo("  • dark      - Otimizado para UIs escuras")
+    click.echo("  • superres  - Super-resolução com IA")
+    click.echo("\n💡 Use 'imgboost process --help' para mais informações")
+
+
+if __name__ == '__main__':
+    cli()

imgboost/core.py

@@ -0,0 +1,162 @@
+import os
+from pathlib import Path
+import cv2
+from .processors.filters import ImageFilters
+from .processors.document import DocumentProcessor
+from .processors.superres import SuperResolution
+from .utils.image_io import ImageIO
+
+
+class Engine:
+    """
+    Orquestrador principal do pipeline de processamento de imagens.
+    """
+    
+    def __init__(self, output_dir='output', quality=95, output_format='auto',
+                 denoise_strength=10, contrast_clip=3.0, extra_sharpen=False,
+                 verbose=False):
+        """
+        Inicializa o engine de processamento.
+        
+        Args:
+            output_dir: Diretório de saída
+            quality: Qualidade JPEG (1-100)
+            output_format: Formato de saída ('auto', 'png', 'jpg')
+            denoise_strength: Força do denoise (0-30)
+            contrast_clip: Intensidade do CLAHE (1.0-5.0)
+            extra_sharpen: Aplicar sharpening adicional
+            verbose: Modo verboso
+        """
+        self.output_dir = Path(output_dir)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        
+        self.quality = quality
+        self.output_format = output_format
+        self.denoise_strength = denoise_strength
+        self.contrast_clip = contrast_clip
+        self.extra_sharpen = extra_sharpen
+        self.verbose = verbose
+        
+        # Inicializar processadores
+        self.filters = ImageFilters(
+            denoise_strength=denoise_strength,
+            contrast_clip=contrast_clip
+        )
+        self.doc_processor = DocumentProcessor()
+        self.superres = SuperResolution()
+        self.io = ImageIO()
+    
+    def run(self, input_path, mode='general', upscale=False):
+        """
+        Executa o pipeline de processamento.
+        
+        Args:
+            input_path: Caminho da imagem de entrada
+            mode: Modo de processamento ('general', 'text', 'dark', 'superres')
+            upscale: Aplicar super-resolução
+            
+        Returns:
+            Caminho da imagem de saída
+        """
+        if self.verbose:
+            print(f"[DEBUG] Carregando: {input_path}")
+        
+        # Carregar imagem
+        img = self.io.load(input_path)
+        
+        if img is None:
+            raise ValueError(f"Não foi possível carregar a imagem: {input_path}")
+        
+        # Aplicar processamento baseado no modo
+        if mode == 'general':
+            img = self._process_general(img)
+        elif mode == 'text':
+            img = self._process_text(img)
+        elif mode == 'dark':
+            img = self._process_dark(img)
+        elif mode == 'superres':
+            img = self._process_superres(img)
+        else:
+            raise ValueError(f"Modo desconhecido: {mode}")
+        
+        # Aplicar super-resolução se solicitado
+        if upscale and mode != 'superres':
+            if self.verbose:
+                print("[DEBUG] Aplicando super-resolução...")
+            img = self.superres.upscale(img)
+        
+        # Sharpening extra se solicitado
+        if self.extra_sharpen:
+            if self.verbose:
+                print("[DEBUG] Aplicando sharpen extra...")
+            img = self.filters.sharpen(img, strength=1.5)
+        
+        # Salvar imagem
+        output_path = self._get_output_path(input_path, mode, upscale)
+        
+        if self.verbose:
+            print(f"[DEBUG] Salvando em: {output_path}")
+        
+        self.io.save(img, str(output_path), quality=self.quality)
+        
+        return output_path
+    
+    def _process_general(self, img):
+        """Pipeline de melhoria geral."""
+        img = self.filters.denoise(img)
+        img = self.filters.enhance_contrast(img)
+        img = self.filters.sharpen(img)
+        return img
+    
+    def _process_text(self, img):
+        """Pipeline otimizado para texto e documentos."""
+        # Melhorias básicas
+        img = self.filters.denoise(img)
+        img = self.filters.enhance_contrast(img)
+        
+        # Processamento específico para texto
+        img = self.doc_processor.enhance_text(img)
+        
+        return img
+    
+    def _process_dark(self, img):
+        """Pipeline otimizado para interfaces escuras."""
+        # Processamento específico para UIs escuras
+        img = self.filters.denoise(img, strength=self.denoise_strength * 0.7)
+        img = self.filters.enhance_dark_ui(img)
+        img = self.filters.sharpen(img, strength=0.8)
+        
+        return img
+    
+    def _process_superres(self, img):
+        """Pipeline com foco em super-resolução."""
+        # Limpeza básica antes do upscale
+        img = self.filters.denoise(img, strength=self.denoise_strength * 1.2)
+        
+        # Super-resolução
+        img = self.superres.upscale(img)
+        
+        # Refinamento pós-upscale
+        img = self.filters.enhance_contrast(img)
+        img = self.filters.sharpen(img, strength=0.5)
+        
+        return img
+    
+    def _get_output_path(self, input_path, mode, upscale):
+        """Gera o caminho de saída baseado nas configurações."""
+        input_path = Path(input_path)
+        
+        # Determinar extensão de saída
+        if self.output_format == 'auto':
+            ext = input_path.suffix
+        else:
+            ext = f'.{self.output_format}'
+        
+        # Nome do arquivo com sufixos
+        suffix = f"_{mode}"
+        if upscale:
+            suffix += "_2x"
+        
+        output_name = f"{input_path.stem}{suffix}{ext}"
+        
+        return self.output_dir / output_name

imgboost/processors/__init__.py

@@ -0,0 +1,9 @@
+"""
+Módulo de processadores de imagem.
+"""
+
+from .filters import ImageFilters
+from .document import DocumentProcessor
+from .superres import SuperResolution
+
+__all__ = ['ImageFilters', 'DocumentProcessor', 'SuperResolution']

imgboost/processors/document.py

@@ -0,0 +1,269 @@
+import cv2
+import numpy as np
+
+
+class DocumentProcessor:
+    """
+    Processador especializado para documentos, textos e OCR.
+    """
+    
+    def __init__(self):
+        pass
+    
+    def enhance_text(self, img):
+        """
+        Melhora imagem para leitura de texto.
+        
+        Args:
+            img: Imagem BGR
+            
+        Returns:
+            Imagem otimizada para texto
+        """
+        # Se já for grayscale, usar direto
+        if len(img.shape) == 2:
+            gray = img
+        else:
+            # Converter para grayscale
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # Denoise
+        gray = cv2.fastNlMeansDenoising(gray, None, h=10, templateWindowSize=7, searchWindowSize=21)
+        
+        # Melhorar contraste com CLAHE
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        gray = clahe.apply(gray)
+        
+        # Retornar como BGR para consistência
+        return cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
+    
+    def binarize(self, img, method='adaptive'):
+        """
+        Binariza a imagem para OCR.
+        
+        Args:
+            img: Imagem BGR
+            method: Método de binarização ('adaptive', 'otsu', 'simple')
+            
+        Returns:
+            Imagem binarizada
+        """
+        # Converter para grayscale se necessário
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+        
+        # Denoise primeiro
+        gray = cv2.fastNlMeansDenoising(gray, None, h=10)
+        
+        if method == 'adaptive':
+            # Binarização adaptativa - melhor para iluminação não-uniforme
+            binary = cv2.adaptiveThreshold(
+                gray, 255,
+                cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                cv2.THRESH_BINARY,
+                11, 2
+            )
+        elif method == 'otsu':
+            # Método de Otsu - automático
+            _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        else:
+            # Threshold simples
+            _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
+        
+        return binary
+    
+    def deskew(self, img):
+        """
+        Corrige inclinação do documento.
+        
+        Args:
+            img: Imagem BGR
+            
+        Returns:
+            Imagem com inclinação corrigida
+        """
+        # Converter para grayscale
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+        
+        # Binarizar
+        binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
+        
+        # Detectar ângulo de rotação
+        coords = np.column_stack(np.where(binary > 0))
+        angle = cv2.minAreaRect(coords)[-1]
+        
+        # Ajustar ângulo
+        if angle < -45:
+            angle = -(90 + angle)
+        else:
+            angle = -angle
+        
+        # Rotacionar imagem
+        (h, w) = img.shape[:2]
+        center = (w // 2, h // 2)
+        M = cv2.getRotationMatrix2D(center, angle, 1.0)
+        
+        if len(img.shape) == 3:
+            rotated = cv2.warpAffine(
+                img, M, (w, h),
+                flags=cv2.INTER_CUBIC,
+                borderMode=cv2.BORDER_REPLICATE
+            )
+        else:
+            rotated = cv2.warpAffine(
+                img, M, (w, h),
+                flags=cv2.INTER_CUBIC,
+                borderMode=cv2.BORDER_REPLICATE
+            )
+        
+        return rotated
+    
+    def remove_noise(self, img):
+        """
+        Remove ruído usando morfologia.
+        
+        Args:
+            img: Imagem binária
+            
+        Returns:
+            Imagem limpa
+        """
+        # Kernel para operações morfológicas
+        kernel = np.ones((2, 2), np.uint8)
+        
+        # Opening: remove ruído pequeno
+        opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel, iterations=1)
+        
+        # Closing: fecha buracos pequenos
+        closing = cv2.morphologyEx(opening, cv2.MORPH_CLOSE, kernel, iterations=1)
+        
+        return closing
+    
+    def enhance_for_ocr(self, img):
+        """
+        Pipeline completo de otimização para OCR.
+        
+        Args:
+            img: Imagem BGR
+            
+        Returns:
+            Imagem otimizada para OCR
+        """
+        # Converter para grayscale
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+        
+        # 1. Denoise
+        gray = cv2.fastNlMeansDenoising(gray, None, h=10)
+        
+        # 2. Aumentar contraste
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        gray = clahe.apply(gray)
+        
+        # 3. Binarizar
+        binary = cv2.adaptiveThreshold(
+            gray, 255,
+            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv2.THRESH_BINARY,
+            11, 2
+        )
+        
+        # 4. Limpar ruído
+        binary = self.remove_noise(binary)
+        
+        # 5. Leve sharpen
+        kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]])
+        sharpened = cv2.filter2D(binary, -1, kernel)
+        
+        return sharpened
+    
+    def remove_shadows(self, img):
+        """
+        Remove sombras de documentos fotografados.
+        
+        Args:
+            img: Imagem BGR
+            
+        Returns:
+            Imagem sem sombras
+        """
+        # Converter para LAB
+        lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+        l, a, b = cv2.split(lab)
+        
+        # Aplicar blur para estimar iluminação
+        blur = cv2.GaussianBlur(l, (0, 0), sigmaX=3, sigmaY=3)
+        
+        # Normalizar
+        l = cv2.divide(l, blur, scale=255)
+        
+        # Recombinar
+        lab = cv2.merge([l, a, b])
+        img = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+        
+        return img
+    
+    def increase_dpi(self, img, target_dpi=300, current_dpi=72):
+        """
+        Aumenta DPI da imagem para impressão/OCR.
+        
+        Args:
+            img: Imagem BGR
+            target_dpi: DPI desejado
+            current_dpi: DPI atual
+            
+        Returns:
+            Imagem com DPI aumentado
+        """
+        scale = target_dpi / current_dpi
+        
+        width = int(img.shape[1] * scale)
+        height = int(img.shape[0] * scale)
+        
+        # Usar INTER_CUBIC ou INTER_LANCZOS4 para upscaling
+        resized = cv2.resize(img, (width, height), interpolation=cv2.INTER_LANCZOS4)
+        
+        return resized
+    
+    def detect_text_regions(self, img):
+        """
+        Detecta regiões de texto na imagem.
+        
+        Args:
+            img: Imagem BGR
+            
+        Returns:
+            Lista de bounding boxes (x, y, w, h)
+        """
+        # Converter para grayscale
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+        
+        # Binarizar
+        binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
+        
+        # Operações morfológicas para conectar texto
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (20, 5))
+        dilated = cv2.dilate(binary, kernel, iterations=2)
+        
+        # Encontrar contornos
+        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Extrair bounding boxes
+        boxes = []
+        for contour in contours:
+            x, y, w, h = cv2.boundingRect(contour)
+            # Filtrar regiões muito pequenas
+            if w > 50 and h > 20:
+                boxes.append((x, y, w, h))
+        
+        return boxes