Update app.py

app.py

@@ -6,125 +6,110 @@ class RubiksCube4x4:
     def __init__(self):
         self.size = 4
         self.cube = np.zeros((6, 4, 4), dtype=int)
-        for i in range(6):
+        
+        # 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)
         
         self.color_names = {
-            0: "Branco",   # Face superior
-            1: "Amarelo",  # Face inferior
-            2: "Verde",    # Face frontal
-            3: "Azul",     # Face traseira
-            4: "Vermelho", # Face direita
-            5: "Laranja"   # Face esquerda
+            0: "Branco",
+            1: "Amarelo",
+            2: "Verde",
+            3: "Azul",
+            4: "Vermelho",
+            5: "Laranja"
         }
-        
-        self.moves_history = []
-    
-    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) == 16:  # 4x4 = 16 cores
-            self.cube[face_num] = np.array(colors).reshape(4, 4)
-        else:
-            raise ValueError(f"Face {face_num} precisa de exatamente 16 cores")
     
     def get_solution(self):
-        """
-        Retorna a sequência de movimentos para resolver o cubo.
-        Implementa uma solução básica para cubo 4x4.
-        """
+        """Retorna sequência de passos para resolver o cubo"""
         solution = []
         
-        # 1. Resolver centros
-        solution.extend(self._solve_centers())
-        
-        # 2. Emparelhar arestas
-        solution.extend(self._pair_edges())
-        
-        # 3. Resolver como um 3x3
-        solution.extend(self._solve_as_3x3())
+        # 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 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")
+        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("")
+        
+        # Passos para resolver
+        solution.append("Passos para resolução:")
+        solution.append("1. Resolver centros")
+        solution.append("   - Agrupar peças verdes na face superior")
+        solution.append("   - Agrupar peças amarelas na face inferior")
+        solution.append("   - Alinhar centros das faces laterais")
+        solution.append("2. Resolver bordas")
+        solution.append("   - Parear bordas usando método de slice")
+        solution.append("   - Corrigir paridade se necessário")
+        solution.append("3. Resolver como 3x3x3")
+        solution.append("   - Usar algoritmos adaptados para 4x4x4")
+        solution.append("4. Verificar e corrigir paridades")
         
         return solution
-    
-    def _solve_centers(self):
-        """Resolve os centros do cubo"""
-        moves = [
-            "1. Alinhe os centros brancos",
-            "2. Gire a face superior até alinhar",
-            "3. Repita para os centros amarelos",
-            "4. Complete os centros laterais"
-        ]
-        return moves
-    
-    def _pair_edges(self):
-        """Emparelha as arestas"""
-        moves = [
-            "1. Identifique pares de arestas",
-            "2. Use o algoritmo de flipe para alinhar",
-            "3. Repita para todas as arestas"
-        ]
-        return moves
-    
-    def _solve_as_3x3(self):
-        """Resolve como um cubo 3x3"""
-        moves = [
-            "1. Resolva a cruz branca",
-            "2. Resolva os cantos brancos",
-            "3. Resolva as arestas do meio",
-            "4. Faça a cruz amarela",
-            "5. Posicione os cantos amarelos",
-            "6. Oriente os cantos amarelos"
-        ]
-        return moves
 
-def create_interface():
-    cube = RubiksCube4x4()
+def create_visualization(cube_state):
+    fig, ax = plt.subplots(4, 4, figsize=(12, 12))
+    plt.subplots_adjust(hspace=0.4, wspace=0.4)
     
-    def process_input(face0, face1, face2, face3, face4, face5):
-        try:
-            # Define as cores para cada face
-            faces = [face0, face1, face2, face3, face4, face5]
-            for i, face in enumerate(faces):
-                cube.set_face(i, face)
-            
-            # Obtém a solução
-            solution = cube.get_solution()
-            
-            # Cria visualização
-            fig = create_visualization(cube.cube)
-            
-            return fig, "\n".join(solution)
-            
-        except Exception as e:
-            return None, f"Erro: {str(e)}"
+    colors = {
+        0: "#FFFFFF",  # Branco
+        1: "#FFFF00",  # Amarelo
+        2: "#00FF00",  # Verde
+        3: "#0000FF",  # Azul
+        4: "#FF0000",  # Vermelho
+        5: "#FFA500"   # Laranja
+    }
     
-    def create_visualization(cube_state):
-        fig, ax = plt.subplots(4, 4, figsize=(12, 12))
-        plt.subplots_adjust(hspace=0.4, wspace=0.4)
-        
-        # Configuração das cores
-        colors = {
-            0: "#FFFFFF",  # Branco
-            1: "#FFFF00",  # Amarelo
-            2: "#00FF00",  # Verde
-            3: "#0000FF",  # Azul
-            4: "#FF0000",  # Vermelho
-            5: "#FFA500"   # Laranja
-        }
-        
-        # Posições das faces no layout
-        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
-        ]
-        
-        # Desenhar cada face
-        for face_idx, (row, col) in enumerate(face_positions):
+    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
+    ]
+    
+    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):
@@ -138,54 +123,37 @@ def create_interface():
             ax[row, col].set_ylim(0, 1)
             ax[row, col].set_xticks([])
             ax[row, col].set_yticks([])
-            ax[row, col].set_title(f'Face {cube.color_names[face_idx]}')
-        
-        # Remover subplots não utilizados
-        for i in range(4):
-            for j in range(4):
-                if (i, j) not in face_positions:
-                    fig.delaxes(ax[i, j])
-        
-        return fig
+            ax[row, col].set_title(f'Face {face_idx} ({self.color_names[face_idx]})')
+    
+    for i in range(4):
+        for j in range(4):
+            if (i, j) not in face_positions:
+                fig.delaxes(ax[i, j])
+    
+    return fig
 
-    # Interface Gradio
-    with gr.Blocks(title="Resolvedor de Cubo Mágico 4x4") as demo:
-        gr.Markdown("""
-        # Resolvedor de Cubo Mágico 4x4
-        
-        Digite as cores de cada face (16 números por face, separados por vírgula):
-        - 0: Branco (face superior)
-        - 1: Amarelo (face inferior)
-        - 2: Verde (face frontal)
-        - 3: Azul (face traseira)
-        - 4: Vermelho (face direita)
-        - 5: Laranja (face esquerda)
-        
-        Exemplo para uma face branca: 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
-        """)
-        
-        with gr.Row():
-            with gr.Column():
-                face0 = gr.Textbox(label="Face Superior (Branco)", value="0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0")
-                face1 = gr.Textbox(label="Face Inferior (Amarelo)", value="1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1")
-                face2 = gr.Textbox(label="Face Frontal (Verde)", value="2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2")
-                face3 = gr.Textbox(label="Face Traseira (Azul)", value="3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3")
-                face4 = gr.Textbox(label="Face Direita (Vermelho)", value="4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4")
-                face5 = gr.Textbox(label="Face Esquerda (Laranja)", value="5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5")
-                solve_btn = gr.Button("Resolver Cubo")
-        
-        with gr.Row():
-            cube_vis = gr.Plot(label="Visualização do Cubo")
-            solution = gr.Textbox(label="Solução", lines=10)
-        
-        solve_btn.click(
-            fn=process_input,
-            inputs=[face0, face1, face2, face3, face4, face5],
-            outputs=[cube_vis, solution]
-        )
+def show_cube_state():
+    cube = RubiksCube4x4()
+    fig = create_visualization(cube.cube)
+    solution = "\n".join(cube.get_solution())
+    return fig, solution
+
+# Criar interface Gradio
+with gr.Blocks(title="Cubo Mágico 4x4 - Análise de Padrões") as demo:
+    gr.Markdown("""
+    # Cubo Mágico 4x4 - Análise de Padrões
+    
+    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
+    """)
+    
+    with gr.Row():
+        cube_vis = gr.Plot(label="Visualização do Cubo")
+        solution = gr.Textbox(label="Análise e Solução", lines=20)
     
-    return demo
+    demo.load(fn=show_cube_state, outputs=[cube_vis, solution])
 
-# Iniciar a aplicação
-demo = create_interface()
+# Iniciar aplicação
 demo.launch()