Upload 3 files

app.py

@@ -8,37 +8,45 @@ with gr.Blocks() as demo:
         mascara = gr.ImageEditor(label="Marcar áreas para preservar (opcional)")
     with gr.Row():
         idade = gr.Slider(minimum=4, maximum=12, step=1, value=6, label="Idade da criança (ajusta número de pontos)")
+        posicao = gr.Radio(["Topo da página", "Centro da página", "Base da página"], value="Centro da página", label="Posicionamento do desenho")
     contraste_alerta = gr.Textbox(label="Aviso de Contraste", interactive=False)
     with gr.Row():
         imagem_resultado = gr.Image(label="Prévia com Pontos Numerados")
+        sobreposicao = gr.Image(label="Preview com Sobreposição")
     with gr.Row():
         gerar_btn = gr.Button("Gerar Pontos")
         salvar_btn = gr.Button("Salvar como PDF")
+        salvar_png = gr.Button("Salvar como PNG")
         capa_btn = gr.Button("Gerar Preview da Capa")
-        saida_pdf = gr.File(label="Download do PDF")
+        saida_pdf = gr.File(label="Download PDF")
+        saida_png = gr.File(label="Download PNG")
         saida_capa = gr.Image(label="Preview da Capa")
 
     resultado = {}
 
-    def gerar(imagem_array, mask_array, idade):
+    def gerar(imagem_array, mask_array, idade, posicao):
         global resultado
         if imagem_array is None:
-            return "⚠️ Nenhuma imagem enviada.", None
+            return "⚠️ Nenhuma imagem enviada.", None, None
         aviso = verificar_contraste(imagem_array)
         try:
-            resultado = processar_e_mostrar(imagem_array, mask_array, idade)
-            return aviso, resultado["preview"]
+            resultado = processar_e_mostrar(imagem_array, mask_array, idade, posicao)
+            return aviso, resultado["preview"], resultado["overlay"]
         except Exception as e:
-            return f"Erro: {str(e)}", None
+            return f"Erro: {str(e)}", None, None
 
     def salvar_pdf():
         return resultado.get("pdf") if resultado else None
 
+    def salvar_imagem():
+        return resultado.get("png") if resultado else None
+
     def gerar_capa():
         return gerar_preview_kdp()
 
-    gerar_btn.click(gerar, inputs=[imagem_input, mascara, idade], outputs=[contraste_alerta, imagem_resultado])
+    gerar_btn.click(gerar, inputs=[imagem_input, mascara, idade, posicao], outputs=[contraste_alerta, imagem_resultado, sobreposicao])
     salvar_btn.click(salvar_pdf, outputs=saida_pdf)
+    salvar_png.click(salvar_imagem, outputs=saida_png)
     capa_btn.click(gerar_capa, outputs=saida_capa)
 
 demo.launch()

livro.py

@@ -3,87 +3,129 @@ import cv2
 import numpy as np
 from reportlab.pdfgen import canvas
 from reportlab.lib.units import inch
-import tempfile
 from PIL import Image, ImageDraw, ImageFont
+from sklearn.neighbors import NearestNeighbors
+import tempfile
 
 PAGE_WIDTH = 8.67 * inch
 PAGE_HEIGHT = 11.5 * inch
 MARGIN = 0.5 * inch
 
 def verificar_contraste(imagem_array):
+    # Converte para escala de cinza e calcula o desvio padrão para avaliar contraste
     gray = cv2.cvtColor(imagem_array, cv2.COLOR_BGR2GRAY)
     contrast = gray.std()
-    if contrast < 30:
-        return "⚠️ Baixo contraste detectado! Use uma imagem com contorno escuro e fundo branco puro."
-    return "✅ Contraste adequado."
+    return "⚠️ Baixo contraste detectado!" if contrast < 30 else "✅ Contraste adequado."
 
-def detectar_pontos(imagem_array, mascara_array=None, idade=6):
+def detectar_pontos(imagem_array, mascara_array, idade, distancia_maxima=50):
+    # Preprocessamento da imagem
     gray = cv2.cvtColor(imagem_array, cv2.COLOR_BGR2GRAY)
     _, thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY_INV)
 
+    # Aplica a máscara para preservar regiões (remover pontos dessas áreas)
     if mascara_array is not None and isinstance(mascara_array, np.ndarray):
         try:
-            mask = cv2.cvtColor(mascara_array, cv2.COLOR_BGR2GRAY)
-            _, mask_thresh = cv2.threshold(mask, 10, 255, cv2.THRESH_BINARY)
-            thresh = cv2.bitwise_and(thresh, mask_thresh)
+            mask_gray = cv2.cvtColor(mascara_array, cv2.COLOR_BGR2GRAY)
+            _, mask_thresh = cv2.threshold(mask_gray, 10, 255, cv2.THRESH_BINARY)
+            thresh[mask_thresh > 0] = 0
         except Exception as e:
             print("Erro ao processar máscara:", e)
 
+    # Encontra contornos
     contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
     if not contours:
-        return []
+        return [], None
 
     main_contour = max(contours, key=cv2.contourArea)
-    max_points = min(30 + (idade - 4) * 10, 150)
-    approx = [tuple(pt[0]) for pt in main_contour[::max(1, len(main_contour)//max_points)]]
-    return sorted(approx, key=lambda p: (p[1], p[0]))
-
-def gerar_preview_com_pontos(pontos):
-    largura = 600
-    altura = 800
-    margem = 50
-
-    preview = np.ones((altura, largura, 3), dtype=np.uint8) * 255
 
+    # Reduz a quantidade de pontos mantendo a forma
+    epsilon = 1.0  # Quanto maior, mais simplificado
+    simplified = cv2.approxPolyDP(main_contour, epsilon, closed=False)
+
+    # Ajusta número com base na idade da criança
+    max_pontos = min(30 + (idade - 4) * 10, 100)
+    step = max(1, len(simplified) // max_pontos)
+    pontos = [tuple(pt[0]) for pt in simplified[::step]]
+
+    # Organiza sequencialmente para evitar pontos muito distantes
+    if len(pontos) > 2:
+        ordenados = [pontos[0]]
+        restantes = pontos[1:]
+        while restantes:
+            ultimo = ordenados[-1]
+            prox = min(restantes, key=lambda p: np.hypot(p[0]-ultimo[0], p[1]-ultimo[1]))
+            if np.hypot(p[0]-ultimo[0], p[1]-ultimo[1]) > distancia_maxima:
+                break
+            ordenados.append(prox)
+            restantes.remove(prox)
+        pontos = ordenados
+    return pontos, thresh
+
+def normalizar_para_preview(pontos, largura=600, altura=800, margem=50, posicao="Centro da página"):
     if not pontos:
-        return None
+        return [], 0
 
+    # Escala os pontos para caber no canvas
     x_coords, y_coords = zip(*pontos)
     min_x, max_x = min(x_coords), max(x_coords)
     min_y, max_y = min(y_coords), max(y_coords)
-
     escala_x = (largura - 2 * margem) / (max_x - min_x + 1e-5)
     escala_y = (altura - 2 * margem) / (max_y - min_y + 1e-5)
     escala = min(escala_x, escala_y)
 
+    altura_desenho = (max_y - min_y) * escala
+    if posicao == "Topo da página":
+        offset_y = margem
+    elif posicao == "Base da página":
+        offset_y = altura - margem - altura_desenho
+    else:  # Centro
+        offset_y = (altura - altura_desenho) // 2
+
     pontos_normalizados = [(
         int((x - min_x) * escala + margem),
-        int((y - min_y) * escala + margem)
+        int((y - min_y) * escala + offset_y)
     ) for x, y in pontos]
+    return pontos_normalizados, escala
 
-    for i, (x, y) in enumerate(pontos_normalizados):
-        cv2.circle(preview, (x, y), 4, (0, 0, 0), -1)
-        cv2.putText(preview, str(i+1), (x + 5, y - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)
+def gerar_preview_com_pontos(pontos, posicao):
+    largura, altura = 600, 800
+    margem = 50
+    img = np.ones((altura, largura, 3), dtype=np.uint8) * 255
+    pontos_norm, _ = normalizar_para_preview(pontos, largura, altura, margem, posicao)
+
+    for i, (x, y) in enumerate(pontos_norm):
+        cv2.circle(img, (x, y), 4, (0, 0, 0), -1)
+        cv2.putText(img, str(i+1), (x + 6, y - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)
+
+    path = tempfile.NamedTemporaryFile(delete=False, suffix=".png").name
+    cv2.imwrite(path, img)
+    return path, img, pontos_norm
+
+def gerar_overlay(original, pontos_norm):
+    overlay = original.copy()
+    h, w = overlay.shape[:2]
+    resize = cv2.resize(overlay, (w, h))
 
-    preview_path = tempfile.NamedTemporaryFile(delete=False, suffix=".png").name
-    cv2.imwrite(preview_path, preview)
-    return preview_path
+    transparente = cv2.addWeighted(resize, 0.5, np.ones_like(resize) * 255, 0.5, 0)
 
-def gerar_pdf(pontos):
-    temp_pdf = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
-    c = canvas.Canvas(temp_pdf.name, pagesize=(PAGE_WIDTH, PAGE_HEIGHT))
-    for i, (x, y) in enumerate(pontos):
+    for i, (x, y) in enumerate(pontos_norm):
+        if x < w and y < h:
+            cv2.circle(transparente, (x, y), 4, (0, 0, 0), -1)
+            cv2.putText(transparente, str(i+1), (x + 6, y - 6), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 0), 1)
+
+    path = tempfile.NamedTemporaryFile(delete=False, suffix=".png").name
+    cv2.imwrite(path, transparente)
+    return path
+
+def gerar_pdf(pontos_norm):
+    pdf_path = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf").name
+    c = canvas.Canvas(pdf_path, pagesize=(PAGE_WIDTH, PAGE_HEIGHT))
+    for i, (x, y) in enumerate(pontos_norm):
         c.circle(x, PAGE_HEIGHT - y, 2, fill=1)
         c.setFont("Helvetica", 8)
         c.drawString(x + 3, PAGE_HEIGHT - y + 3, str(i + 1))
     c.save()
-    return temp_pdf.name
-
-def processar_e_mostrar(imagem_array, mascara_array, idade):
-    pontos = detectar_pontos(imagem_array, mascara_array, idade)
-    preview = gerar_preview_com_pontos(pontos)
-    pdf = gerar_pdf(pontos)
-    return {"preview": preview, "pdf": pdf}
+    return pdf_path
 
 def gerar_preview_kdp():
     img = Image.new("RGB", (1500, 1000), color=(250, 240, 210))
@@ -94,6 +136,20 @@ def gerar_preview_kdp():
     draw.text((580, 160), "For Kids Ages 4 to 12", fill="black", font=font)
     draw.ellipse((1100, 700, 1300, 900), outline="gray", width=3)
     draw.text((1120, 780), "Your Art Here", fill="gray", font=font)
-    capa_path = tempfile.NamedTemporaryFile(delete=False, suffix=".png").name
-    img.save(capa_path)
-    return capa_path
+    path = tempfile.NamedTemporaryFile(delete=False, suffix=".png").name
+    img.save(path)
+    return path
+
+def processar_e_mostrar(imagem_array, mascara_array, idade, posicao):
+    pontos, original_masked = detectar_pontos(imagem_array, mascara_array, idade)
+    preview_path, preview_img, pontos_norm = gerar_preview_com_pontos(pontos, posicao)
+    overlay_path = gerar_overlay(cv2.resize(imagem_array, (600, 800)), pontos_norm)
+    pdf_path = gerar_pdf(pontos_norm)
+    png_path = tempfile.NamedTemporaryFile(delete=False, suffix=".png").name
+    cv2.imwrite(png_path, preview_img)
+    return {
+        "preview": preview_path,
+        "overlay": overlay_path,
+        "pdf": pdf_path,
+        "png": png_path
+    }

requirements.txt

@@ -3,3 +3,4 @@ opencv-python
 numpy
 reportlab
 pillow
+scikit-learn