Commit a860e3cd authored by Tom MARRUCCI's avatar Tom MARRUCCI
Browse files

Merge branch 'optimisation_ftl' of gitlab.univ-nantes.fr:E132397K/Ragnulf into optimisation_ftl

Conflicts:
	algo.py
parents 84a6ff5f e5611e35
......@@ -4,7 +4,29 @@ See http://keepachangelog.com
## [Unreleased]
## v0.4.0 - 07/01/2016
### Fixed
- Fix #18. La liste des mouvements était parfois incomplète
### Changed
- Amélioration du tuto
## v0.3.0 - 05/01/2016
### Added
- Résolution complète d'un cube par `poqb.py`
- Sortie animée avec `--tuto`
## v0.2.0 - 16/12/2015
### Added
- Lecture d'un cube par `lecture_cube()` dans `lire_entree.py`
- Ajout d'une fonction `Cube.get_facette(cube, indice)`
- Algorithme de résolution dans `algo.py`.
Non optimisé, pas encore utilisé dans `poqb.py`.
## v0.1.0 - 01/12/2015
### Added
- modélisation du Rubik's Cube en petits cubes (après comparaison avec version d'Arnaud)
- Modélisation du Rubik's Cube en petits cubes (après comparaison avec version d'Arnaud)
......@@ -3,10 +3,63 @@
Ragnulf
=======
Resolution d'un Rubik's Kube - Projet Algorithmique et Programmation INFO3
Résolution d'un Rubik's Cube par la méthode CFOP.
## Membres :
Projet d'Algorithmique et Programmation INFO3 Polytech Nantes.
# TL;DR
```bash
python poqb.y --cube OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG
```
# Utilisation
## Dépendances
- Python 3
- Numpy (`pip install numpy`).
## Terminal
```bash
python poqb.py [--cube | -c] <cube> [--tuto] [--auto] [--speed | -s] <speed> [--colors]
```
- `--cube <cube>` (optionnel). Un cube à résoudre.
Par défaut on résout `OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG`.
Format : 54 couleurs parmis {Y, B, R, G, O, W} pour les 54 facettes.
- `-c<cube>` (optionnel). Voir `--cube`.
- `--tuto` (optionnel).
Activer le mode tutoriel qui affiche la résoltution du cube pas à pas.
- `--auto` (optionnel).
Avec `--tuto`, avancée automatique.
- `--speed <speed>` (optionnel).
La vitesse d'avancée avec `--auto` en mouvements par secondes. Défaut 2/sec.
- `-s<speed>` (optionnel). Voir `--speed`.
- `--colors` (optionnel).
Activer les couleurs ascii sous Windows, par exemple
dans Git Bash.
## Module
```python
import poqb #import du fichier poqb.py
print(poqb.solve('OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG'))
#U2F2F'...
```
# En savoir plus
[:link: Wiki Gitlab](https://gitlab.univ-nantes.fr/E132397K/Ragnulf/wikis/home)
# Membres :
- CLOCHARD Guillaume
- LANGELIER Arnaud
- MARRUCCI Tom
......
This diff is collapsed.
from Cube import Cube
from utils import Array
from utils import Array, colorize, translate_mvt, readArgs
from algo import algo_cfop
from lire_entree import lecture_cube
from tuto import tuto
DEFAULT_CUBE = 'OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG'
def solve(cube_c54):
"""La fonction principale du projet qui résoud un Rubik's Cube.
:param cube_c54: passé sous sa forme '54 facettes colorées'
O G R
B W Y
B G B
G Y Y O Y O W O W G R Y
O O O B G B R R Y R B W
W W R B W Y G R O W G R
Y B R
G Y W
B O G
:return: une chaîne de caractères qui encode la manoeuvre
qui mène du cube de départ à la permutation monochrome.
"""
solve
La fonction principale du projet qui résoud un Rubik's Cube.
:Args:
cube_c54 {String} Le cube passé sous sa forme '54 facettes colorées'
O G R
B W Y
B G B
G Y Y O Y O W O W G R Y
O O O B G B R R Y R B W
W W R B W Y G R O W G R
Y B R
G Y W
B O G
:Returns:
{String} une chaîne de caractères qui encode la manoeuvre
qui mène du cube de départ à la permutation monochrome.
:Example:
solve('OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG')
solve('OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG')
"""
err, mvts, _ = solve_full(cube_c54)
print(err)
if err:
return err
else:
mvts = [translate_mvt(m) for m in mvts] #on remplace les i en '
return ''.join(mvts)
def solve_full(cube_c54):
"""
solve_full
pass
return "ch'sais pas faire..."
:Args:
cube_c54 {String} Le cube passé sous sa forme '54 facettes colorées'
:Returns:
({String|None}, {None|List}, {None|Cube})
(erreur, liste des mouvements, cube en entrée)
"""
err, cube_lu = lecture_cube(cube_c54)
if err:
return err, None, None
else:
err, mouvements = algo_cfop(cube_lu.copy())
return (err, None, None) if err \
else (None, mouvements, cube_lu)
if __name__=="__main__":
cube = 'OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG'
print ("Pour la résolution de {}\nExécuter la manoeuvre {}".format(cube, solve(cube)))
"""
:Example:
python poqb.py
python poqb.py -cYYYYYYYYYOOOBBBRRRGGGOOOBBBRRRGGGOOOBBBRRRGGGWWWWWWWWW
python poqb.py --cube=YYYYYYYYYOOOBBBRRRGGGOOOBBBRRRGGGOOOBBBRRRGGGWWWWWWWWW
"""
#On récupère le cube en paramètre ou on utilise celui par défaut
params = readArgs()
cube = str(params['cube']) if 'cube' in params else DEFAULT_CUBE
err, resolution, cube_lu = solve_full(cube)
if err:
print("Erreur dans la lecture du cube : " + err)
else:
#L'utilisateur a demandé la résolution pas à pas
if 'tuto' in params:
print('Résolution de :', "".join([colorize(x) for x in cube]))
tuto(cube_lu, resolution)
print('Résolution de :', "".join([colorize(x) for x in cube]) +'\n')
resolution = " ".join([translate_mvt(x) for x in resolution])
print('Positionnez la face bleue face à vous et la face blanche face au sol\n')
print("Puis exécutez la manoeuvre : {}".format(resolution) +'\n')
from time import sleep
from utils import clear, readArgs, colorize, translate_mvt, newGetch, TermColors
from algo import algo_cfop
SPEED = 2 #écrans / sec
def tuto(cube, mouvements):
"""
tuto
:Args:
cube {Cube} Un cube à la sortie de lecture_cube
mouvements {List} Suite de mouvements à appliquer sur le cube
pour le résoudre, calculée par algo_cfop()
"""
#lecture des paramètres
params = readArgs()
speed = float(params['speed']) if 'speed' in params else SPEED
resolution = " ".join([translate_mvt(x) for x in mouvements])
mouvementsDone = []
mouvementsRestants = list(mouvements)
clear()
print("Exécution de la manoeuvre : {}".format(resolution) )
print(cube)
for m in mouvements:
clear()
mouvementsRestants.remove(m)
method = getattr(cube, 'rot_' + m)
method()
print(
"Exécution de la manoeuvre : "
#les mouvements effectués
+ TermColors.green + \
"{}".format(" ".join([translate_mvt(x) for x in mouvementsDone]))+ \
TermColors.end + ' ' +
#le mouvement actuel
TermColors.bgGreen + translate_mvt(m) + TermColors.end + \
#les mouvements restant
" {}".format(" ".join([translate_mvt(x) \
for x in mouvementsRestants])
) + '\n'
)
print(cube)
print("Rotation : ", translate_mvt(m) +'\n\n')
mouvementsDone.append(m)
if 'auto' not in params:
print('Press any key to continue . . .\n')
newGetch()
else:
sleep(1 / speed)
if __name__ == '__main__':
from lire_entree import lecture_cube
cube = 'OGRBWYBGBGYYOYOWOWGRYOOOBGBRRYRBWWWRBWYGROWGRYBRGYWBOG'
error, c = lecture_cube(cube)
if error:
raise Error(error)
c0 = c.copy()
mouvements = algo_cfop(c)
tuto(c0, mouvements)
import numpy as np
import sys
from os import name as os_name
import subprocess
import getopt
COULEURS = ['W', 'B', 'R', 'G', 'O', 'Y']
......@@ -18,6 +21,63 @@ def Array(arr):
"""
return np.array(arr, dtype=np.int8)
def readArgs():
"""
readArgs
Lecture des arguments passés au script, version avancée.
En particulier, on veut lire --cube=<cube à résoudre>
ou -c=<cube à résoudre>
:Returns:
{Dict} {cube: <cube à résoudre>} uniquement pour l'instant
"""
result = {}
optlist, args = getopt.getopt(
sys.argv[1:],
'c:s:taC',
['cube=',
'speed=',
'tuto',
'auto',
'colors']
)
arguments = {k: v for k, v in optlist} #on tranforme la list en dict
if '-c' in arguments:
result['cube'] = arguments['-c']
if '--cube' in arguments:
result['cube'] = arguments['--cube'] #--cube override -c
if '-s' in arguments:
result['speed'] = arguments['-s']
if '--speed' in arguments:
result['speed'] = arguments['--speed'] #--speed override -s
if '-t' in arguments:
result['tuto'] = arguments['-t']
if '--tuto' in arguments:
result['tuto'] = arguments['--tuto'] #--tuto override -t
if '-a' in arguments:
result['auto'] = arguments['-a']
if '--auto' in arguments:
result['auto'] = arguments['--auto'] #--auto override -a
if '-C' in arguments:
result['colors'] = arguments['-C']
if '--colors' in arguments:
result['colors'] = arguments['--colors'] #--colors override -C
return result
def codeToColor(code):
"""
codeToColor
......@@ -176,7 +236,8 @@ class winTermColors():
pass
#Windows n'aime pas trop les couleurs ascii
if os_name == 'nt' and not '--colors' in sys.argv:
params = readArgs()
if os_name == 'nt' and not 'colors' in params:
TermColors = winTermColors()
else:
TermColors = unixTermColors()
......@@ -296,6 +357,59 @@ def cfop_valide(cube, mouvements):
cube.mouvements(mouvements)
return cube.resolu()
def translate_mvt(mvt):
"""
translate_mvt
Traduit les mouvements inverses *i en *'
:Args:
mvt {String}
:Returns:
{String}
"""
if len(mvt) > 1 and mvt[1]=="i" :
mvt = mvt[0] + "'"
return mvt
def clear():
"""
clear
Clear terminal screen
Voir : http://stackoverflow.com/a/1433135/2058840
"""
if os_name == 'nt':
subprocess.call("cls", shell=True) # windows, attention ne marche pas sur gitbash
else:
subprocess.call("clear") # linux/mac
def newGetch():
"""
newGetch
Ecoute le premier caractère saisi par l'user
Voir : http://code.activestate.com/recipes/134892/
"""
if os_name == 'nt': # windows
from msvcrt import getch
return getch()
else: # linux/mac
import tty, termios
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
if __name__ == '__main__':
print("Test unixTermColors")
c = unixTermColors()
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment