Update routers/news.py

routers/news.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter, Query, HTTPException
 from fastapi.responses import StreamingResponse
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image, ImageDraw
 from io import BytesIO
 import requests
-from typing import Optional, List, Union
+from typing import Optional
 
 router = APIRouter()
 
@@ -22,15 +22,14 @@ def download_image_from_url(url: str) -> Image.Image:
     except Exception as e:
         raise HTTPException(status_code=400, detail=f"Erro ao baixar imagem: {url} ({str(e)})")
 
-def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height: int, crop_position: str = "center") -> Image.Image:
+def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height: int) -> Image.Image:
     """
-    Redimensiona e corta a imagem para preencher exatamente o espaço alvo.
+    Redimensiona e corta a imagem para preencher exatamente o espaço alvo (sempre centralizado).
     
     Args:
         img: Imagem PIL
         target_width: Largura alvo
         target_height: Altura alvo
-        crop_position: Posição do crop ('center', 'top', 'bottom', 'left', 'right')
     """
     img_ratio = img.width / img.height
     target_ratio = target_width / target_height
@@ -46,400 +45,77 @@ def resize_and_crop_to_fill(img: Image.Image, target_width: int, target_height:
     
     img_resized = img.resize((scale_width, scale_height), Image.LANCZOS)
     
-    # Calcular posição do crop baseado na opção escolhida
-    if crop_position.lower() == "center":
-        left = (scale_width - target_width) // 2
-        top = (scale_height - target_height) // 2
-    elif crop_position.lower() == "top":
-        left = (scale_width - target_width) // 2
-        top = 0
-    elif crop_position.lower() == "bottom":
-        left = (scale_width - target_width) // 2
-        top = scale_height - target_height
-    elif crop_position.lower() == "left":
-        left = 0
-        top = (scale_height - target_height) // 2
-    elif crop_position.lower() == "right":
-        left = scale_width - target_width
-        top = (scale_height - target_height) // 2
-    else:
-        # Default para center se opção inválida
-        left = (scale_width - target_width) // 2
-        top = (scale_height - target_height) // 2
-    
+    # Centralizar o crop
+    left = (scale_width - target_width) // 2
+    top = (scale_height - target_height) // 2
     right = left + target_width
     bottom = top + target_height
     
     return img_resized.crop((left, top, right, bottom))
 
-def create_collage_background(image_urls: List[str], canvas_width: int, canvas_height: int, crop_position: str = "center") -> Image.Image:
-    """Cria uma colagem como fundo baseada na lista de URLs"""
-    num_images = len(image_urls)
-    border_size = 4 if num_images > 1 else 0  # Linha mais fina e elegante
-    
-    images = [download_image_from_url(url) for url in image_urls]
-    canvas = Image.new("RGBA", (canvas_width, canvas_height), (255, 255, 255, 255))
-    
-    if num_images == 1:
-        img = resize_and_crop_to_fill(images[0], canvas_width, canvas_height, crop_position)
-        canvas.paste(img, (0, 0))
-    elif num_images == 2:
-        # Lado a lado
-        slot_width = (canvas_width - border_size) // 2
-        img1 = resize_and_crop_to_fill(images[0], slot_width, canvas_height, crop_position)
-        img2 = resize_and_crop_to_fill(images[1], slot_width, canvas_height, crop_position)
-        canvas.paste(img1, (0, 0))
-        canvas.paste(img2, (slot_width + border_size, 0))
-    elif num_images == 3:
-        # Layout original IG
-        half_height = (canvas_height - border_size) // 2
-        half_width = (canvas_width - border_size) // 2
-        
-        img1 = resize_and_crop_to_fill(images[0], half_width, half_height, crop_position)
-        img2 = resize_and_crop_to_fill(images[1], half_width, half_height, crop_position)
-        img3 = resize_and_crop_to_fill(images[2], canvas_width, half_height, crop_position)
-        
-        canvas.paste(img1, (0, 0))
-        canvas.paste(img2, (half_width + border_size, 0))
-        canvas.paste(img3, (0, half_height + border_size))
-    elif num_images == 4:
-        # Layout 2x2
-        half_height = (canvas_height - border_size) // 2
-        half_width = (canvas_width - border_size) // 2
-        
-        img1 = resize_and_crop_to_fill(images[0], half_width, half_height, crop_position)
-        img2 = resize_and_crop_to_fill(images[1], half_width, half_height, crop_position)
-        img3 = resize_and_crop_to_fill(images[2], half_width, half_height, crop_position)
-        img4 = resize_and_crop_to_fill(images[3], half_width, half_height, crop_position)
-        
-        canvas.paste(img1, (0, 0))
-        canvas.paste(img2, (half_width + border_size, 0))
-        canvas.paste(img3, (0, half_height + border_size))
-        canvas.paste(img4, (half_width + border_size, half_height + border_size))
-    elif num_images == 5:
-        # Layout original IG
-        top_height = (canvas_height - border_size) * 2 // 5
-        bottom_height = canvas_height - top_height - border_size
-        half_width = (canvas_width - border_size) // 2
-        
-        img1 = resize_and_crop_to_fill(images[0], half_width, top_height, crop_position)
-        img2 = resize_and_crop_to_fill(images[1], half_width, top_height, crop_position)
-        canvas.paste(img1, (0, 0))
-        canvas.paste(img2, (half_width + border_size, 0))
-        
-        y_offset = top_height + border_size
-        third_width = (canvas_width - 2 * border_size) // 3
-        third_width_last = canvas_width - (third_width * 2 + border_size * 2)
-        
-        img3 = resize_and_crop_to_fill(images[2], third_width, bottom_height, crop_position)
-        img4 = resize_and_crop_to_fill(images[3], third_width, bottom_height, crop_position)
-        img5 = resize_and_crop_to_fill(images[4], third_width_last, bottom_height, crop_position)
-        canvas.paste(img3, (0, y_offset))
-        canvas.paste(img4, (third_width + border_size, y_offset))
-        canvas.paste(img5, (third_width * 2 + border_size * 2, y_offset))
-    elif num_images == 6:
-        # Layout original IG (3x2)
-        half_height = (canvas_height - border_size) // 2
-        third_width = (canvas_width - 2 * border_size) // 3
-        third_width_last = canvas_width - (third_width * 2 + border_size * 2)
-        
-        # Primeira linha
-        img1 = resize_and_crop_to_fill(images[0], third_width, half_height, crop_position)
-        img2 = resize_and_crop_to_fill(images[1], third_width, half_height, crop_position)
-        img3 = resize_and_crop_to_fill(images[2], third_width, half_height, crop_position)
-        canvas.paste(img1, (0, 0))
-        canvas.paste(img2, (third_width + border_size, 0))
-        canvas.paste(img3, (third_width * 2 + border_size * 2, 0))
-        
-        # Segunda linha
-        y_offset = half_height + border_size
-        img4 = resize_and_crop_to_fill(images[3], third_width, half_height, crop_position)
-        img5 = resize_and_crop_to_fill(images[4], third_width, half_height, crop_position)
-        img6 = resize_and_crop_to_fill(images[5], third_width_last, half_height, crop_position)
-        canvas.paste(img4, (0, y_offset))
-        canvas.paste(img5, (third_width + border_size, y_offset))
-        canvas.paste(img6, (third_width * 2 + border_size * 2, y_offset))
-    else:
-        raise HTTPException(status_code=400, detail="Apenas até 6 imagens são suportadas.")
-    
-    return canvas
 
-def parse_image_urls(image_url_param: Union[str, List[str]]) -> List[str]:
-    """Converte o parâmetro de URL(s) em lista de URLs"""
-    if isinstance(image_url_param, list):
-        return image_url_param
-    elif isinstance(image_url_param, str):
-        # Se contém vírgulas, divide em múltiplas URLs
-        if ',' in image_url_param:
-            return [url.strip() for url in image_url_param.split(',') if url.strip()]
-        else:
-            return [image_url_param]
-    return []
 
-def create_gradient_overlay(width: int, height: int, text_position: str = "bottom") -> Image.Image:
-    """ Cria gradiente overlay baseado na posição do texto """
+def create_gradient_overlay(width: int, height: int) -> Image.Image:
+    """ Cria o novo gradiente overlay conforme especificado """
     gradient = Image.new("RGBA", (width, height))
     draw = ImageDraw.Draw(gradient)
     
-    # Novo gradiente: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, rgba(0, 0, 0, 0.85) 55.77%, #000000 100%)
-    # Posição: top: 262px, altura: 1088px
-    gradient_start = 262
-    gradient_height = 1088
+    # Novo gradiente: linear-gradient(180deg, rgba(0, 0, 0, 0) 0%, rgba(0, 0, 0, 0.4) 55%, rgba(0, 0, 0, 0.5) 100%)
+    # Posição: left: 0px, top: 808px, width: 1080px, height: 542px
+    gradient_start = 808
+    gradient_height = 542
     
     for y in range(gradient_height):
         if y + gradient_start < height:
             ratio = y / gradient_height
-            if ratio <= 0.5577:  # 0% a 55.77%: de transparente para rgba(0,0,0,0.85)
-                opacity_ratio = ratio / 0.5577
-                opacity = int(255 * 0.85 * opacity_ratio)
-            else:  # 55.77% a 100%: de rgba(0,0,0,0.85) para #000000 (opaco)
-                opacity_ratio = (ratio - 0.5577) / (1 - 0.5577)
-                opacity = int(255 * (0.85 + 0.15 * opacity_ratio))
+            if ratio <= 0.55:  # 0% a 55%: de transparente para rgba(0,0,0,0.4)
+                opacity_ratio = ratio / 0.55
+                opacity = int(255 * 0.4 * opacity_ratio)
+            else:  # 55% a 100%: de rgba(0,0,0,0.4) para rgba(0,0,0,0.5)
+                opacity_ratio = (ratio - 0.55) / (1 - 0.55)
+                opacity = int(255 * (0.4 + 0.1 * opacity_ratio))
             
             draw.line([(0, y + gradient_start), (width, y + gradient_start)], fill=(0, 0, 0, opacity))
     
     return gradient
 
-def wrap_text(text: str, font: ImageFont.FreeTypeFont, max_width: int, draw: ImageDraw.Draw) -> list[str]:
-    words = text.split()
-    lines = []
-    current_line = ""
-    
-    for word in words:
-        test_line = f"{current_line} {word}".strip()
-        if draw.textlength(test_line, font=font) <= max_width:
-            current_line = test_line
-        else:
-            if current_line:
-                lines.append(current_line)
-            current_line = word
-    
-    if current_line:
-        lines.append(current_line)
-    
-    return lines
-
-def get_responsive_font_and_lines(text: str, font_path: str, max_width: int, max_lines: int = 3, font_size: int = 55, min_font_size: int = 20) -> tuple[ImageFont.FreeTypeFont, list[str], int]:
-    """ Retorna a fonte e linhas ajustadas para caber no número máximo de linhas. """
-    temp_img = Image.new("RGB", (1, 1))
-    temp_draw = ImageDraw.Draw(temp_img)
-    
-    current_font_size = font_size
-    while current_font_size >= min_font_size:
-        try:
-            font = ImageFont.truetype(font_path, current_font_size)
-        except Exception:
-            font = ImageFont.load_default()
-        
-        lines = wrap_text(text, font, max_width, temp_draw)
-        if len(lines) <= max_lines:
-            return font, lines, current_font_size
-        
-        current_font_size -= 1
-    
-    try:
-        font = ImageFont.truetype(font_path, min_font_size)
-    except Exception:
-        font = ImageFont.load_default()
-    
-    lines = wrap_text(text, font, max_width, temp_draw)
-    return font, lines, min_font_size
-
-def get_text_color_rgb(text_color: str) -> tuple[int, int, int]:
-    """ Converte o parâmetro text_color para RGB. """
-    if text_color.lower() == "black":
-        return (0, 0, 0)
-    else:  # white por padrão
-        return (255, 255, 255)
-
-def create_category_image(category: str, type_param: str = "news", base_width: int = 200, height: int = 46) -> Image.Image:
-    """Cria uma imagem de categoria dinamicamente com largura responsiva"""
-    
-    # Configurações
-    text_padding_left = 20
-    text_padding_right = 15
-    ball_size = 41  # Aumentado de 33 para 41
-    ball_margin = 3
-    
-    # Definir cores baseadas no type
-    if type_param.lower() == "pop":
-        bg_color = (4, 196, 234, 255)      # #04C4EA
-        ball_color = (143, 244, 255, 255)  # #8FF4FF
-        text_color = (255, 255, 255, 255)  # Branco para pop
-    else:  # "news" ou qualquer outro valor
-        bg_color = (85, 90, 208, 255)      # #555AD0 (nova cor)
-        ball_color = (146, 134, 255, 255)  # #9286FF (nova cor da bola)
-        text_color = (255, 255, 255, 255)  # Branco para news (alterado de preto)
-    
-    # Carregar fonte
-    try:
-        font = ImageFont.truetype("fonts/Montserrat-Bold.ttf", 22)
-    except Exception:
-        font = ImageFont.load_default()
-    
-    # Texto da categoria em maiúsculo
-    category_text = category.upper()
-    
-    # Calcular largura do texto
-    temp_img = Image.new("RGBA", (1, 1))
-    temp_draw = ImageDraw.Draw(temp_img)
-    text_bbox = temp_draw.textbbox((0, 0), category_text, font=font)
-    text_width = text_bbox[2] - text_bbox[0]
-    text_height = text_bbox[3] - text_bbox[1]
-    
-    # Calcular largura total necessária
-    # padding esquerdo + texto + padding direito + bola + margem da bola
-    required_width = text_padding_left + text_width + text_padding_right + ball_size + ball_margin
-    
-    # Usar a largura maior entre a base e a necessária
-    final_width = max(base_width, required_width)
-    
-    # Criar imagem com largura responsiva
-    category_img = Image.new("RGBA", (final_width, height), (0, 0, 0, 0))
-    draw = ImageDraw.Draw(category_img)
-    
-    # Desenhar o fundo com bordas arredondadas
-    radius = height // 2  # Bordas totalmente arredondadas baseadas na altura
-    
-    draw.rounded_rectangle([(0, 0), (final_width-1, height-1)], radius=radius, fill=bg_color)
-    
-    # Posicionar a bola no canto direito
-    ball_x = final_width - ball_size - ball_margin
-    ball_y = (height - ball_size) // 2
-    
-    # Desenhar a bola
-    draw.ellipse([ball_x, ball_y, ball_x + ball_size, ball_y + ball_size], fill=ball_color)
-    
-    # Calcular área disponível para texto (espaço total menos bola e margens)
-    text_area_width = ball_x - (text_padding_left + text_padding_right)
-    
-    # Posicionar texto centralizado na área disponível
-    text_x = text_padding_left + (text_area_width - text_width) // 2
-    
-    # Centralizar texto verticalmente de forma mais precisa
-    # Usar a baseline da fonte para alinhamento mais preciso
-    text_y = (height - text_height) // 2 - text_bbox[1]  # Compensar offset da bbox
-    
-    # Desenhar o texto com a cor apropriada
-    draw.text((text_x, text_y), category_text, font=font, fill=text_color)
-    
-    return category_img
-
-def create_canvas(image_url: Optional[Union[str, List[str]]], headline: Optional[str], text_position: str = "bottom", text_color: str = "white", crop_position: str = "center", breaking_news: bool = False, category: str = "other", type: str = "news", show_category: bool = True) -> BytesIO:
+def create_canvas(image_url: Optional[str]) -> BytesIO:
     # Dimensões fixas do Instagram
     width, height = 1080, 1350
-    text_rgb = get_text_color_rgb(text_color)
     
-    # Configurações do Instagram
-    padding_x = 60
-    bottom_padding = 100
-    top_padding = 60
+    # Configurações da logo
     logo_width, logo_height = 121, 23
     
-    max_width = width - 2 * padding_x
     canvas = Image.new("RGBA", (width, height), color=(255, 255, 255, 255))
     
-    # Adicionar imagem(s) de fundo se fornecida(s)
+    # Adicionar imagem de fundo se fornecida
     if image_url:
-        parsed_urls = parse_image_urls(image_url)
-        if parsed_urls:
-            if len(parsed_urls) > 6:
-                raise HTTPException(status_code=400, detail="Máximo de 6 imagens permitidas")
-            
-            if len(parsed_urls) == 1:
-                # Uma única imagem - comportamento original
-                img = download_image_from_url(parsed_urls[0])
-                filled_img = resize_and_crop_to_fill(img, width, height, crop_position)
-                canvas.paste(filled_img, (0, 0))
-            else:
-                # Múltiplas imagens - criar colagem
-                canvas = create_collage_background(parsed_urls, width, height, crop_position)
+        img = download_image_from_url(image_url)
+        filled_img = resize_and_crop_to_fill(img, width, height)
+        canvas.paste(filled_img, (0, 0))
     
-    # Adicionar gradiente se o texto for branco
-    if text_color.lower() != "black":
-        gradient_overlay = create_gradient_overlay(width, height, text_position)
-        canvas = Image.alpha_composite(canvas, gradient_overlay)
+    # Adicionar o novo gradiente
+    gradient_overlay = create_gradient_overlay(width, height)
+    canvas = Image.alpha_composite(canvas, gradient_overlay)
     
-    if headline:
-        draw = ImageDraw.Draw(canvas)
-        font_path = "fonts/Montserrat-SemiBold.ttf"  # Nova fonte
-        line_height_factor = 1.05  # 105% da altura da linha
-        
-        try:
-            font, lines, font_size = get_responsive_font_and_lines(
-                headline, font_path, max_width, max_lines=3, font_size=55, min_font_size=20  # Tamanho fixo 55px
-            )
-            line_height = int(font_size * line_height_factor)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Erro ao processar a fonte: {e}")
-        
-        total_text_height = len(lines) * line_height
-        
-        # Calcular espaço necessário para imagem de categoria/breaking
-        category_img_height = 0
-        category_spacing = 0
-        if (breaking_news or (category and show_category)):
-            category_img_height = 46  # altura da nova imagem de categoria
-            category_spacing = 20     # separação entre imagem e título (reduzido de 38 para 20)
-        
-        # Posicionar texto baseado no parâmetro text_position
-        if text_position.lower() == "bottom":
-            # Logo está em Y:1256, texto deve ficar 100px acima da logo
-            text_bottom_y = 1256 - 100  # Y: 1176
-            start_y = text_bottom_y - total_text_height
-            
-            # Se há imagem de categoria, ajustar posição para dar espaço ACIMA do texto
-            if (breaking_news or (category and show_category)):
-                category_y = start_y - category_spacing - category_img_height
-        else:  # text_position == "top"
-            # Posicionar texto no topo com padding
-            start_y = top_padding
-            
-            # Se há imagem de categoria, ajustar posição para aparecer ABAIXO do texto
-            if (breaking_news or (category and show_category)):
-                category_y = start_y + total_text_height + category_spacing
-        
-        # Adicionar imagem de categoria/breaking se necessário
-        if (breaking_news or (category and show_category)):
-            try:
-                if breaking_news:
-                    # Breaking news ainda carrega PNG
-                    img_path = "breaking.png"
-                    category_img = Image.open(img_path).convert("RGBA")
-                    category_resized = category_img.resize((200, 46))
-                else:
-                    # Criar imagem de categoria dinamicamente
-                    category_resized = create_category_image(category, type)
-                
-                # Posicionar no canto esquerdo, alinhado com o início do título
-                category_x = padding_x
-                canvas.paste(category_resized, (category_x, category_y), category_resized)
-            except Exception as e:
-                raise HTTPException(status_code=500, detail=f"Erro ao criar a imagem de categoria: {e}")
-        
-        # Adicionar logo no canto inferior direito (posição fixa)
-        try:
-            logo_path = "recurve.png"
-            logo = Image.open(logo_path).convert("RGBA")
-            logo_resized = logo.resize((logo_width, logo_height))
-            
-            # Aplicar opacidade de 42%
-            logo_with_opacity = Image.new("RGBA", logo_resized.size)
-            for x in range(logo_resized.width):
-                for y in range(logo_resized.height):
-                    r, g, b, a = logo_resized.getpixel((x, y))
-                    new_alpha = int(a * 0.42)  # 42% de opacidade
-                    logo_with_opacity.putpixel((x, y), (r, g, b, new_alpha))
-            
-            # Posição alterada: X:70, Y:1256
-            canvas.paste(logo_with_opacity, (70, 1256), logo_with_opacity)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=f"Erro ao carregar a logo: {e}")
-        
-        # Adiciona texto com a cor especificada
-        for i, line in enumerate(lines):
-            y = start_y + i * line_height
-            draw.text((padding_x, y), line, font=font, fill=text_rgb)
+    # Adicionar logo na nova posição (X: 880, Y: 1260)
+    try:
+        logo_path = "recurve.png"
+        logo = Image.open(logo_path).convert("RGBA")
+        logo_resized = logo.resize((logo_width, logo_height))
+        
+        # Aplicar opacidade de 42%
+        logo_with_opacity = Image.new("RGBA", logo_resized.size)
+        for x in range(logo_resized.width):
+            for y in range(logo_resized.height):
+                r, g, b, a = logo_resized.getpixel((x, y))
+                new_alpha = int(a * 0.42)  # 42% de opacidade
+                logo_with_opacity.putpixel((x, y), (r, g, b, new_alpha))
+        
+        # Nova posição: X:880, Y:1260
+        canvas.paste(logo_with_opacity, (880, 1260), logo_with_opacity)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erro ao carregar a logo: {e}")
     
     buffer = BytesIO()
     canvas.convert("RGB").save(buffer, format="PNG")
@@ -448,18 +124,10 @@ def create_canvas(image_url: Optional[Union[str, List[str]]], headline: Optional
 
 @router.get("/cover/news")
 def get_news_image(
-    image_url: Optional[Union[str, List[str]]] = Query(None, description="URL da imagem ou lista de URLs separadas por vírgula para colagem (máximo 6)"),
-    headline: Optional[str] = Query(None, description="Texto do título"),
-    text_position: str = Query("bottom", description="Posição do texto: 'top' para topo ou 'bottom' para parte inferior"),
-    text_color: str = Query("white", description="Cor do texto: 'white' (padrão) ou 'black'. Se 'black', remove o gradiente de fundo"),
-    crop_position: str = Query("center", description="Posição do enquadramento da imagem: 'center' (padrão), 'top', 'bottom', 'left', 'right'"),
-    breaking_news: bool = Query(False, description="Se true, mostra a imagem breaking.png acima do título (tem prioridade sobre category)"),
-    category: str = Query("other", description="Categoria da notícia: 'person', 'movie', 'series', 'place', 'event', 'other' (padrão)"),
-    type: str = Query("news", description="Tipo da categoria: 'news' (roxo, texto branco) ou 'pop' (azul, texto branco)"),
-    show_category: bool = Query(True, description="Se deve mostrar a categoria (true) ou não (false)")
+    image_url: Optional[str] = Query(None, description="URL da imagem de fundo")
 ):
     try:
-        buffer = create_canvas(image_url, headline, text_position, text_color, crop_position, breaking_news, category, type, show_category)
+        buffer = create_canvas(image_url)
         return StreamingResponse(buffer, media_type="image/png")
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erro ao gerar imagem: {str(e)}")