Update app.py

app.py

@@ -2,85 +2,63 @@ import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
 
-class RubiksCube4x4:
+class RubiksCube2x2:
     def __init__(self):
-        self.size = 4
-        self.cube = np.zeros((6, 4, 4), dtype=int)
+        self.size = 2
+        self.cube = np.zeros((6, 2, 2), dtype=int)
         
-        # Inicializar com padrões específicos
-        # Face 1: 2 verdes, 1 vermelho, 1 azul, resto amarelo
-        self.cube[1] = np.full((4, 4), 1)  # Preenche tudo com amarelo
-        self.cube[1][0][0] = 2  # Verde
-        self.cube[1][0][1] = 2  # Verde
-        self.cube[1][1][0] = 4  # Vermelho
-        self.cube[1][1][1] = 3  # Azul
-        
-        # Face 2: 2 laranjas, 1 branco, 1 amarelo, resto verde
-        self.cube[2] = np.full((4, 4), 2)  # Preenche tudo com verde
-        self.cube[2][0][0] = 5  # Laranja
-        self.cube[2][0][1] = 5  # Laranja
-        self.cube[2][1][0] = 0  # Branco
-        self.cube[2][1][1] = 1  # Amarelo
-        
-        # Face 4: 1 verde, 1 vermelho, 1 azul, 1 amarelo, resto vermelho
-        self.cube[4] = np.full((4, 4), 4)  # Preenche tudo com vermelho
-        self.cube[4][0][0] = 2  # Verde
-        self.cube[4][0][1] = 4  # Vermelho
-        self.cube[4][1][0] = 3  # Azul
-        self.cube[4][1][1] = 1  # Amarelo
-        
-        # Outras faces com cores padrão
-        for i in [0,3,5]:
-            self.cube[i] = np.full((4, 4), i)
+        # Inicializar faces com cores padrão
+        for i in range(6):
+            self.cube[i] = np.full((2, 2), i)
         
         self.color_names = {
-            0: "Branco",
-            1: "Amarelo",
-            2: "Verde",
-            3: "Azul",
-            4: "Vermelho",
-            5: "Laranja"
+            0: "Branco",   # Face superior
+            1: "Amarelo",  # Face inferior
+            2: "Verde",    # Face frontal
+            3: "Azul",     # Face traseira
+            4: "Vermelho", # Face direita
+            5: "Laranja"   # Face esquerda
         }
     
+    def set_face(self, face_num, colors):
+        """Define as cores de uma face específica"""
+        if isinstance(colors, str):
+            colors = [int(c) for c in colors.split(',') if c.strip()]
+        if len(colors) == 4:  # 2x2 = 4 cores
+            self.cube[face_num] = np.array(colors).reshape(2, 2)
+        else:
+            raise ValueError(f"Face {face_num} precisa de exatamente 4 cores")
+
     def get_solution(self):
         """Retorna sequência de passos para resolver o cubo"""
         solution = []
         
-        # Analisar face 1
-        solution.append("Análise da Face 1:")
-        solution.append("- Encontrados 2 centros verdes")
-        solution.append("- Encontrado 1 centro vermelho")
-        solution.append("- Encontrado 1 centro azul")
-        solution.append("- Restante em amarelo")
-        solution.append("")
+        # Analisar cada face
+        for face in range(6):
+            colors_in_face = np.unique(self.cube[face])
+            solution.append(f"\nAnálise da Face {self.color_names[face]}:")
+            for color in colors_in_face:
+                count = np.count_nonzero(self.cube[face] == color)
+                solution.append(f"- {count}x {self.color_names[color]}")
         
-        # Analisar face 2
-        solution.append("Análise da Face 2:")
-        solution.append("- Encontrados 2 centros laranja")
-        solution.append("- Encontrado 1 centro branco")
-        solution.append("- Encontrado 1 centro amarelo")
-        solution.append("- Restante em verde")
+        # Passos para solução
+        solution.append("\nPassos para resolução:")
+        solution.append("1. Resolver face branca")
+        solution.append("   - Posicionar peças brancas na face superior")
+        solution.append("   - Alinhar cores adjacentes")
         solution.append("")
-        
-        # Analisar face 4
-        solution.append("Análise da Face 4:")
-        solution.append("- Encontrado 1 centro verde")
-        solution.append("- Encontrado 1 centro vermelho")
-        solution.append("- Encontrado 1 centro azul")
-        solution.append("- Encontrado 1 centro amarelo")
-        solution.append("- Restante em vermelho")
+        solution.append("2. Resolver face amarela")
+        solution.append("   - Orientar peças amarelas")
+        solution.append("   - Posicionar cantos corretamente")
         solution.append("")
-        
-        solution.append("Passos para resolução:")
-        solution.append("1. Resolver centros")
-        solution.append("2. Resolver bordas")
-        solution.append("3. Resolver como 3x3x3")
-        solution.append("4. Corrigir paridades")
+        solution.append("3. Verificar alinhamento")
+        solution.append("   - Alinhar faces laterais")
+        solution.append("   - Corrigir orientação se necessário")
         
         return solution
 
 def create_visualization(cube_state):
-    fig, ax = plt.subplots(4, 4, figsize=(12, 12))
+    fig, ax = plt.subplots(3, 4, figsize=(10, 8))
     plt.subplots_adjust(hspace=0.4, wspace=0.4)
     
     colors = {
@@ -102,60 +80,104 @@ def create_visualization(cube_state):
     }
     
     face_positions = [
-        (1, 1),  # Face superior
-        (2, 1),  # Face frontal
-        (1, 2),  # Face direita
-        (1, 0),  # Face esquerda
-        (3, 1),  # Face inferior
-        (2, 2),  # Face traseira
+        (0, 1),  # Face superior (branco)
+        (1, 1),  # Face frontal (verde)
+        (1, 2),  # Face direita (vermelho)
+        (1, 0),  # Face esquerda (laranja)
+        (2, 1),  # Face inferior (amarelo)
+        (1, 3),  # Face traseira (azul)
     ]
     
     for face_idx, (row, col) in enumerate(face_positions):
-        if row < 4 and col < 4:
-            face = cube_state[face_idx]
-            for i in range(4):
-                for j in range(4):
-                    color = colors[face[i, j]]
-                    ax[row, col].add_patch(plt.Rectangle(
-                        (j/4, (3-i)/4), 1/4, 1/4,
-                        facecolor=color,
-                        edgecolor='black'
-                    ))
-            ax[row, col].set_xlim(0, 1)
-            ax[row, col].set_ylim(0, 1)
-            ax[row, col].set_xticks([])
-            ax[row, col].set_yticks([])
-            ax[row, col].set_title(f'Face {face_idx} ({color_names[face_idx]})')
-    
-    for i in range(4):
+        face = cube_state[face_idx]
+        for i in range(2):
+            for j in range(2):
+                color = colors[face[i, j]]
+                ax[row, col].add_patch(plt.Rectangle(
+                    (j/2, (1-i)/2), 1/2, 1/2,
+                    facecolor=color,
+                    edgecolor='black'
+                ))
+        ax[row, col].set_xlim(0, 1)
+        ax[row, col].set_ylim(0, 1)
+        ax[row, col].set_xticks([])
+        ax[row, col].set_yticks([])
+        ax[row, col].set_title(f'Face {color_names[face_idx]}')
+    
+    # Remover subplots não utilizados
+    for i in range(3):
         for j in range(4):
             if (i, j) not in face_positions:
                 fig.delaxes(ax[i, j])
     
     return fig
 
-def show_cube_state():
-    cube = RubiksCube4x4()
-    fig = create_visualization(cube.cube)
-    solution = "\n".join(cube.get_solution())
-    return fig, solution
+def process_input(colors_input):
+    """Processa a entrada de cores e retorna visualização e solução"""
+    cube = RubiksCube2x2()
+    
+    try:
+        # Separar entrada em faces
+        faces = colors_input.strip().split('\n')
+        if len(faces) > 6:
+            faces = faces[:6]
+        
+        # Configurar cada face
+        for i, face in enumerate(faces):
+            if face.strip():
+                cube.set_face(i, face)
+        
+        fig = create_visualization(cube.cube)
+        solution = "\n".join(cube.get_solution())
+        return fig, solution
+    
+    except Exception as e:
+        return None, f"Erro ao processar entrada: {str(e)}"
 
 # Criar interface Gradio
-with gr.Blocks(title="Cubo Mágico 4x4 - Análise de Padrões") as demo:
+with gr.Blocks(title="Cubo Mágico 2x2") as demo:
     gr.Markdown("""
-    # Cubo Mágico 4x4 - Análise de Padrões
+    # Resolvedor de Cubo Mágico 2x2
+    
+    Digite as cores para cada face (4 números por face, separados por vírgula):
+    - 0: Branco
+    - 1: Amarelo
+    - 2: Verde
+    - 3: Azul
+    - 4: Vermelho
+    - 5: Laranja
+    
+    Exemplo para uma face branca:
+    0,0,0,0
     
-    Visualização do cubo com os padrões especificados:
-    - Face 1: 2 verdes, 1 vermelho, 1 azul, resto amarelo
-    - Face 2: 2 laranjas, 1 branco, 1 amarelo, resto verde
-    - Face 4: 1 verde, 1 vermelho, 1 azul, 1 amarelo, resto vermelho
+    Digite uma face por linha, na ordem:
+    1. Face Superior (normalmente branca)
+    2. Face Inferior (normalmente amarela)
+    3. Face Frontal (normalmente verde)
+    4. Face Traseira (normalmente azul)
+    5. Face Direita (normalmente vermelha)
+    6. Face Esquerda (normalmente laranja)
     """)
     
+    with gr.Row():
+        input_text = gr.Textbox(
+            label="Digite as cores (uma face por linha)",
+            lines=6,
+            placeholder="0,0,0,0\n1,1,1,1\n2,2,2,2\n3,3,3,3\n4,4,4,4\n5,5,5,5"
+        )
+    
+    with gr.Row():
+        submit_btn = gr.Button("Analisar Cubo")
+    
     with gr.Row():
         cube_vis = gr.Plot(label="Visualização do Cubo")
         solution = gr.Textbox(label="Análise e Solução", lines=20)
     
-    demo.load(fn=show_cube_state, outputs=[cube_vis, solution])
+    submit_btn.click(
+        fn=process_input,
+        inputs=[input_text],
+        outputs=[cube_vis, solution]
+    )
 
 # Iniciar aplicação
 demo.launch()