Update app.py

app.py

@@ -3,138 +3,120 @@
 import gradio as gr
 import cv2
 import numpy as np
-from PIL import Image
+from PIL import Image, ImageDraw, ImageFont
 import pytesseract
 import re
+import requests
+import json
 
-# Função para encontrar todas as caixas retangulares (componentes como ICs, resistores)
-def find_component_boxes(image):
-    # Converte para escala de cinza e aplica um limiar para isolar formas
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    _, thresh = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY_INV)
-    
-    # Encontra contornos
-    contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    
-    boxes = []
-    for cnt in contours:
-        # Aproxima o contorno a um polígono
-        approx = cv2.approxPolyDP(cnt, 0.02 * cv2.arcLength(cnt, True), True)
-        # Filtra por área para remover ruído
-        if cv2.contourArea(cnt) > 100:
-            x, y, w, h = cv2.boundingRect(approx)
-            # Componentes são tipicamente retangulares, não muito finos nem muito quadrados
-            aspect_ratio = w / float(h)
-            if 1.2 < aspect_ratio < 10 or 0.1 < aspect_ratio < 0.8:
-                boxes.append((x, y, w, h))
-    return boxes
+# --- MÓDULO 1: API WRAPPER PARA A OCTOPART ---
+OCTOPART_API_KEY = "SUA_CHAVE_API_AQUI" # <-- SUBSTITUA PELA SUA CHAVE REAL
 
-# Função para remover os componentes e isolar as trilhas
-def find_wires(image, boxes):
-    # Converte para escala de cinza e aplica um limiar
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    _, thresh = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY_INV)
+def get_component_data_from_api(part_number):
+    """Consulta a API da Octopart para obter dados de um componente."""
+    if OCTOPART_API_KEY == "SUA_CHAVE_API_AQUI":
+        return None, "Erro: Chave de API da Octopart não configurada."
 
-    # Cria uma máscara para apagar os componentes
-    component_mask = np.zeros_like(thresh)
-    for (x, y, w, h) in boxes:
-        # Desenha retângulos preenchidos para apagar os componentes
-        cv2.rectangle(component_mask, (x, y), (x + w, y + h), 255, -1)
-        
-    # Dilata a máscara para também apagar o texto próximo
-    component_mask = cv2.dilate(component_mask, np.ones((10,10)), iterations=2)
+    url = f"http://octopart.com/api/v3/parts/match?apikey={OCTOPART_API_KEY}"
+    queries = [{'mpn': part_number}]
     
-    # Subtrai os componentes, deixando apenas as trilhas
-    wires_mask = cv2.subtract(thresh, component_mask)
-    
-    # Limpeza final para remover pequenas linhas e ruído
-    wires_mask = cv2.morphologyEx(wires_mask, cv2.MORPH_OPEN, np.ones((3,1)))
-    wires_mask = cv2.morphologyEx(wires_mask, cv2.MORPH_OPEN, np.ones((1,3)))
+    try:
+        response = requests.post(url, data=json.dumps({'queries': queries}))
+        response.raise_for_status()
+        data = response.json()
+        
+        if data['results'] and data['results'][0]['hits'] > 0:
+            part_info = data['results'][0]['items'][0]
+            # Extrair o nome do footprint (case) e a URL da ficha técnica
+            specs = part_info.get('specs', {})
+            footprint = specs.get('case_package', {}).get('value', ["Desconhecido"])[0]
+            datasheet_url = part_info.get('datasheet_url', "N/A")
+            return {'footprint': footprint, 'datasheet': datasheet_url}, None
+    except requests.exceptions.RequestException as e:
+        return None, f"Erro de API: {e}"
     
-    return wires_mask
+    return None, f"Componente '{part_number}' não encontrado."
 
-# Função para fazer OCR perto de cada caixa de componente
-def ocr_labels(image, boxes):
-    labels = []
-    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-    
-    for (x, y, w, h) in boxes:
-        # Define uma região de interesse (ROI) expandida à volta da caixa
-        roi_x = max(0, x - 40)
-        roi_y = max(0, y - 40)
-        roi_w = w + 80
-        roi_h = h + 80
-        roi = gray[roi_y:roi_y+roi_h, roi_x:roi_x+roi_w]
-        
-        # Usa Tesseract para ler o texto na ROI
-        text = pytesseract.image_to_string(roi, config='--psm 6')
-        
-        # Filtra e limpa o texto para encontrar identificadores (ex: R1, C1, U1)
-        # Usamos uma expressão regular para encontrar padrões como "letra + número"
-        matches = re.findall(r'[A-Z]\d{1,2}', text, re.IGNORECASE)
-        if matches:
-            # Pega no primeiro identificador encontrado
-            label = matches[0].upper()
-            labels.append((label, (x + w // 2, y + h // 2))) # Guarda o identificador e o centro da caixa
-            
-    return labels
+# --- MÓDULO 2: BIBLIOTECA LOCAL DE FOOTPRINTS ---
+# Mapeia o nome do footprint (obtido da API) para a sua geometria.
+FOOTPRINT_LIBRARY = {
+    "SOIC-14": {"size_mm": (8.65, 3.9), "pin_count": 14},
+    "DIP-28": {"size_mm": (35.56, 7.62), "pin_count": 28},
+    "0805": {"size_mm": (2.0, 1.25), "pin_count": 2}, # Footprint para resistores/capacitores SMD
+    "UNKNOWN": {"size_mm": (10, 10), "pin_count": 2} # Default
+}
 
-def analyze_schematic(image_pil):
+# --- MÓDULO 3: PIPELINE DE ANÁLISE E GERAÇÃO ---
+
+def analyze_and_generate_from_api(image_pil):
     if image_pil is None:
-        return Image.new('RGB', (512, 512)), "Faça o upload de uma imagem."
+        return Image.new('RGB', (1,1)), "Faça o upload de uma imagem."
 
-    # Converte a imagem PIL para o formato do OpenCV
     image_cv = np.array(image_pil.convert("RGB"))
-    image_cv = cv2.cvtColor(image_cv, cv2.COLOR_RGB2BGR)
-    
-    # Etapa 1: Deteção de Componentes
-    component_boxes = find_component_boxes(image_cv)
     
-    # Etapa 2: Deteção de Trilhas (Wires)
-    wires_mask = find_wires(image_cv, component_boxes)
+    # 1. OCR para extrair nomes de componentes (simplificado)
+    text = pytesseract.image_to_string(image_cv)
+    # Procurar por nomes de componentes comuns
+    part_numbers = re.findall(r'LM\d{3}|ATMEGA\d{3,4}P?|NE\d{3}', text, re.IGNORECASE)
+    part_numbers = list(set([p.upper() for p in part_numbers])) # Remove duplicados
     
-    # Etapa 3: Leitura de Texto (OCR)
-    found_labels = ocr_labels(image_cv, component_boxes)
-    
-    # Etapa 4: Visualização dos Resultados
-    vis_image = image_cv.copy()
-    
-    # Desenha as trilhas detetadas em Ciano
-    vis_image[wires_mask > 0] = [255, 255, 0]
+    if not part_numbers:
+        return Image.new('RGB', (1,1)), "Nenhum nome de componente reconhecido via OCR."
+        
+    log = ""
+    placed_components = {}
     
-    # Desenha as caixas dos componentes em Vermelho
-    for (x, y, w, h) in component_boxes:
-        cv2.rectangle(vis_image, (x, y), (x + w, y + h), (0, 0, 255), 2)
+    # 2. Consultar a API e a biblioteca de footprints
+    for i, pn in enumerate(part_numbers):
+        log += f"A procurar por '{pn}'...\n"
+        api_data, error = get_component_data_from_api(pn)
+        if error:
+            log += f"  > {error}\n"
+            continue
+            
+        footprint_name = api_data.get('footprint', "UNKNOWN").upper()
+        # Simplificação: assume que footprints como "SOIC-14" estão na nossa biblioteca.
+        footprint_key = next((k for k in FOOTPRINT_LIBRARY if k in footprint_name), "UNKNOWN")
         
-    # Escreve os identificadores lidos por OCR em Verde
-    for label, center in found_labels:
-        cv2.putText(vis_image, label, (center[0], center[1] - 15), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
-
-    # Geração de um "pseudo-netlist" em texto
-    netlist_str = "--- Netlist Parcial (Componentes Detetados) ---\n"
-    for label, (cx, cy) in found_labels:
-        netlist_str += f"Componente: {label} encontrado em ({cx}, {cy})\n"
-    if not found_labels:
-        netlist_str += "Nenhum identificador de componente foi lido com sucesso via OCR."
+        footprint_data = FOOTPRINT_LIBRARY[footprint_key]
+        log += f"  > Encontrado! Footprint: {footprint_name} -> {footprint_key}\n"
+        log += f"  > Ficha Técnica: {api_data.get('datasheet')}\n"
+        
+        # 3. Placement simples
+        placed_components[pn] = {
+            'center': (150 + i * 200, 200),
+            'footprint': footprint_data
+        }
 
-    return Image.fromarray(cv2.cvtColor(vis_image, cv2.COLOR_BGR2RGB)), netlist_str
+    # 4. Geração do Layout Visual
+    layout_img = Image.new('RGB', (800, 600), '#003300')
+    draw = ImageDraw.Draw(layout_img)
+    DPI = 96; MM_TO_PIXEL = DPI / 25.4
+    
+    for name, data in placed_components.items():
+        cx, cy = data['center']
+        size_mm = data['footprint']['size_mm']
+        w, h = int(size_mm[0] * MM_TO_PIXEL), int(size_mm[1] * MM_TO_PIXEL)
+        
+        draw.rectangle([cx-w//2, cy-h//2, cx+w//2, cy+h//2], outline='gold', width=2)
+        draw.text((cx, cy-h//2 - 10), name, fill='white', anchor="ms")
+        
+    return layout_img, log
 
-# Configuração da Interface Gradio
+# --- Interface Gradio ---
 app = gr.Interface(
-    fn=analyze_schematic,
+    fn=analyze_and_generate_from_api,
     inputs=gr.Image(type="pil", label="Upload do Esquema Elétrico"),
     outputs=[
-        gr.Image(type="pil", label="Visualização da Análise"),
-        gr.Textbox(label="Netlist Parcial / Log de Deteção", lines=10)
+        gr.Image(type="pil", label="Layout com Footprints do Mundo Real"),
+        gr.Textbox(label="Log da API / Análise", lines=15)
     ],
-    title="Analisador de Esquemas Elétricos (Conceito)",
-    description="""Faça o upload de uma imagem de um esquema elétrico. A aplicação irá tentar "ler" o diagrama usando técnicas de visão computacional.
-    
-**Legenda da Visualização:**
-- **Vermelho:** Caixas delimitadoras de componentes detetados.
-- **Ciano:** Linhas de conexão (trilhas/fios) detetadas.
-- **Verde:** Identificadores dos componentes lidos via OCR (ex: R1, U1)."""
+    title="Gerador de PCB com Dados Reais da API Octopart (v16)",
+    description="""**Esta aplicação demonstra um fluxo EDA profissional.**
+1.  **Lê** os nomes dos componentes no esquemático com OCR.
+2.  **Consulta** a API da Octopart na internet para obter dados reais.
+3.  **Extrai** o nome do footprint (ex: SOIC-14) e a ficha técnica.
+4.  **Usa** uma biblioteca local para obter a geometria desse footprint e desenha-o na placa."""
 )
 
 if __name__ == "__main__":