def solveCube(): cube = request.json['cube'] technique = "Beginner" if technique == 'Beginner': steps = utils.solve(cube, 'Beginner') elif technique == "CFOP": steps = utils.solve(cube, 'CFOP') elif technique == "Kociemba": steps = utils.solve(cube, 'Kociemba') output = [str(i) for i in steps] return jsonify({'result': output})
def solve(): print("solving...") cube_string = "" # convert cube to string for row in range(3): for col in range(3): cube_string += char_cube[5][row][col] for side in range(4): for row in range(3): for col in range(3): cube_string += char_cube[side][row][col] for row in range(3): for col in range(3): cube_string += char_cube[4][row][col] # solve cube if (not (is_cube_solved())): solve_steps = utils.solve(cube_string, 'Kociemba') else: solve_steps = [] total_steps = execute_steps(solve_steps) print(solve_steps) print(cube_string) print('Finished solving. Total steps: ', total_steps)
def solve(cube_string): turns = utils.solve(cube_string, 'Kociemba') #list i = 1 string = "" for m in turns: move = str(m) if "'" in move: direction = "counter-clockwise" else: direction = "clockwise" if '2' in move: num = "twice" else: num = "once" if "L" in move: face = "left" elif "F" in move: face = "front" elif "R" in move: face = "right" elif "B" in move: face = "back" elif "U" in move: face = "upper" elif "D" in move: face = "bottom" string += (str(i) + ") " + "Turn the " + face + " face " + num + " " + direction + "\n") i += 1 return(print(string))
def kociemba(cube): #face F doit etre rouge solution = utils.solve(cube, 'Kociemba') s=str(solution) s=s.replace('[','') s=s.replace(']','') liste=s.split(', ') return liste
def solve_all(cube): for m in methods: print('Start process :',m) start = time.time() solution = utils.solve(cube, m) end = time.time() print('Time of process :',end - start,'s') print(solution)
def solve_and_exit(): colors = '' for cube_side in CUBE_SIDES: for row in cube_side.rows: for color in row: # Get the first letter of each color to convert to a # format rubik_solver understands colors += color[0].lower() # Output the rubik_solver solutions to the console # It would be possible to show this using `turtle` too print(utils.solve(colors, 'Beginner')) print(utils.solve(colors, 'CFOP')) print(utils.solve(colors, 'Kociemba')) # Exit the program raise SystemExit()
def callback(data): global pub rospy.loginfo("Solving with Kociemba") msg = StringArray() steps = utils.solve(data.data, 'Kociemba') for s in steps: msg.steps.append(str(s)) pub.publish(msg) rospy.loginfo("Done")
def post(self, request): cube_state = request.data['cube_state'] alg = request.data['alg'] cube = Cube() cube.set_state(cube_state) solve = utils.solve(str(cube), alg) res = { "solve": ",".join(map(str, solve)) } return Response(data=res, status=status.HTTP_200_OK)
def api_solve(): colors = request.args.get("colors") print(colors.lower()) try: rotations = utils.solve(colors.lower(), 'Kociemba') return jsonify({ "status": True, "rotations": [str(i) for i in rotations] }) except: return jsonify({"status": False})
def solve(cube): #call the solver sol_raw = utils.solve(cube, 'Kociemba') sol = [] #initial orientation of the cube (can not be changed) faces = {'U': 'Y', 'L': 'B', 'F': 'R', 'R': 'G', 'B': 'O', 'D': 'W'} #rename the face with the center color #and decompose double rotation as two signle rotations for move in sol_raw: move_string = faces[move.face] if move.counterclockwise: move_string = move_string + "'" sol.append(move_string) if move.double: sol.append(move_string) #translate the solution into moves that the robot can execute moves = [] for m in sol: f = m[0] # the face we want do be facing down print(faces) if faces['U'] == f: faces = rotate_front_CW(faces) moves.append('FCW') faces = rotate_front_CW(faces) moves.append('FCW') elif faces['L'] == f: faces = rotate_front_CCW(faces) moves.append('FCCW') elif faces['F'] == f: faces = rotate_upper_CCW(faces) moves.append('UCCW') faces = rotate_front_CW(faces) moves.append('FCW') elif faces['R'] == f: faces = rotate_front_CW(faces) moves.append('FCW') elif faces['B'] == f: faces = rotate_upper_CW(faces) moves.append('UCW') faces = rotate_front_CW(faces) moves.append('FCW') if "'" in m: faces = rotate_upper_CCW(faces) moves.append('MCCW') else: faces = rotate_upper_CW(faces) moves.append('MCW') print("solved in {} moves".format(len(moves))) return moves
def api_solve(): colors = request.args.get("colors") print(colors.lower()) algorithm = request.args.get("algorithm") if algorithm is None: algorithm = "Kociemba" try: rotations = utils.solve(colors.lower(), algorithm) return jsonify({ "status": True, "rotations": [str(i) for i in rotations] }) except: return jsonify({"status": False})
def LSE_scramble(self): self.cube = SOLVED_CUBE corners = random.choice(range(4)) if corners == 1 or corners == 3: permn = random.choice(o_6) else: permn = random.choice(a_6) flip = random.choice(range(4)) orient = random.sample(range(6), flip * 2) m2 = random.choice(range(2)) LSE_pieces = np.array([[1, 37], [3, 10], [7, 19], [5, 28], [46, 25], [52, 43]]) LSE_pieces_new = LSE_pieces for i in orient: LSE_pieces_new[i] = perm.Permutation(0, 1)(LSE_pieces[i]) LSE_pieces_new = permn(LSE_pieces_new) edge_perm_list = perm.Permutation(53).list() for i in range(12): edge_perm_list[np.asarray(LSE_pieces).reshape(12)[i]] = np.asarray( LSE_pieces_new).reshape(12)[i] scramble_perm = perm.Permutation(11, 20, 29, 38)(6, 8, 2, 0)( 18, 27, 36, 9)**corners * perm.Permutation(edge_perm_list) self.cube = scramble_perm(self.cube) if m2 == 1: self.cube = M2(self.cube) order = scramble_perm.order() inv_scramble = (scramble_perm**(order - 2))(self.cube) empty = "" # scramble = ida_lse(full_to_mu(self.cube)) non_M2_scramble = utils.solve(empty.join(inv_scramble), "Kociemba") M2_scramble = [] if m2 == 1: for mv in non_M2_scramble + ["M2"]: M2_scramble.append( mv) # couldn't directly append M2 so did it this way self.cube = M2(self.cube) else: M2_scramble = non_M2_scramble self.print_cube() self.scramble.set(M2_scramble)
def solve(cubeInStringForm): solution = utils.solve(cubeInStringForm, 'Kociemba') newSol = [] clearSerialBuffer() sleep(3) for step in solution: newSol.append(str(step)) newSol = updateSol(newSol) ind = int(0) for move in newSol: print("Current move: ", move) ser.write(b'%s.' % reverseDict[move].encode('utf-8')) sleep(.5) while ser.in_waiting == 0: pass data = ser.readline().decode('utf-8').strip() if data == 'done': ser.flush() ind += 1
def main(video: Union[str, int]): cap = cv2.VideoCapture(video) state = CubeState() while True: try: process_frame(cap, state) except KeyboardInterrupt: print('User interrupt') break except VideoDone: break except AllSidesFound: print('All sides found') encoded_state = state.encode() solution = utils.solve(encoded_state, 'Kociemba') print(f'Solution: {solution}') break # When everything is done, release the capture cap.release() cv2.destroyAllWindows()
def hello(): cube = 'oobywyywogbbogrgbgrbbyrgogrygwrbwggoryyrobboywowrywrww' step = utils.solve(str(cube), 'Beginner') return 'success'
def validate(self, data): data['solution'] = rubik_utils.solve(data.get('positions', ''), 'Kociemba') return data
from rubik_solver import utils f=open("str.txt","r") a=f.readline() ff=open('solve.txt',"w") c=utils.solve(cube, 'CFOP') for i in c: ff.write(i)
message("Select White as front face and Red as top face") cv2.destroyAllWindows() faces.append(obtainColors(mask)) message("Select Green as front face and White as top face") cv2.destroyAllWindows() cap.release() send = '' for i in faces: for j in i: send += j print(i) print(send) solution = utils.solve(send, 'Kociemba') #from rubik.cube import Cube not used #print(Cube(send)) #Libraries used to acces to comunication import socket import array as arr # Dictionary of cube moves movesDict = { "D": 0, "D2": 1, "D'": 2, "L": 3, "L2": 4, "L'": 5,
def begin(cube): return u.solve(cube, 'Beginner')
# Name: module1 # Purpose: # # Author: Jean # # Created: 24/04/2019 # Copyright: (c) Jean 2019 # Licence: <your licence> #------------------------------------------------------------------------------- from rubik_solver import utils import time methods = ['Beginner', 'CFOP', 'Kociemba'] cube = 'wowgybwyogygybyoggrowbrgywrborwggybrbwororbwborgowryby' for m in methods: print('Start process :', m) start = time.time() solution = utils.solve(cube, m) end = time.time() print('Time of process :', end - start, 's') print(solution) def main(): pass if __name__ == '__main__': main()
from rubik_solver import utils f = open("str.txt", "r") a = f.readline() ff = open('solve.txt', "w") c = utils.solve(cube, 'Kociemba') for i in c: ff.write(i)
w = y = b = g = r = o = 0 sides = ["w", "y", "b", "g", "r", "o"] sideNums = [0, 0, 0, 0, 0, 0] for i in cube: sideNums[sides.index(i)] += 1 maxTiles = max(sideNums[sides.index("w")], sideNums[sides.index("y")], sideNums[sides.index("b")], sideNums[sides.index("g")], sideNums[sides.index("r")], sideNums[sides.index("o")]) # print("Max:", maxTiles) port1 = "com4" port2 = "com10" a_algo = [] if maxTiles == 9: solve = utils.solve(cube, 'Kociemba') # this gets a solve alg algo = [] # this creates an empty list for i in solve: #this will go through your solve tmp = str(i) # it converts the solve instance to a string if len(tmp) == 1: # this will add a space on single clockwise moves tmp += " " a_algo.append(tmp) elif tmp[1] == "'": for i in range(2): a_algo.append(tmp[0] + " ") elif tmp[1] == "2": for i in range(1): a_algo.append(tmp[0] + " ") algo.append(tmp) # this will add the single move to the algo list print(
def test_solve(self): c = Cube() with self.assertRaises(TypeError): utils.solve(c, None) with self.assertRaises(ValueError): utils.solve(None, "INVALID SOLVER") with self.assertRaises(ValueError): utils.solve(None, MockSolver) with self.assertRaises(ValueError): utils.solve(None, self.solve_methods[0]) with self.assertRaises(ValueError): utils.solve(1, self.solve_methods[0]) for method in self.solve_methods: for i in range(10): c = Cube() ref_solution = method(c).solution() s1 = utils.solve(c, method) self.assertEqual(ref_solution, s1, msg="Failed with Cubie.Cube and method %s" % method.__class__.__name__) # Test with NaiveCube s2 = utils.solve(c.to_naive_cube(), method) self.assertEqual(ref_solution, s2, msg="Failed with Cubie.Cube and method %s" % method.__class__.__name__) # Test with string representation s3 = utils.solve(c.to_naive_cube().get_cube(), method) self.assertEqual(ref_solution, s3, msg="Failed with Cubie.Cube and method %s" % method.__class__.__name__)
if (entrada != ''): cara_o = entrada elif color == "w": cara_w = cara[::-1] print('Comprobacion de que la cara es correcta:') print(cara_w) entrada = raw_input( 'Introduce la secuencia de colores correcta o pulsa enter...') if (entrada != ''): cara_w = entrada cube = cara_y + cara_b + cara_r + cara_g + cara_o + cara_w print(cube) movements = utils.solve(cube, 'Kociemba') print(movements) ack = arduino.readline() print('ACK: ' + ack) print('COMENZANDO A RESOLVER EL CUBO...') for mov in movements: print(str(mov)) arduino.write(str(mov)) ack = arduino.readline() print(ack) arduino.write('E')
# folder = 'imgs/FullColor' # folder = 'imgs/Mi_cubo' folder = f'imgs/{sys.argv[1]}' paths = { 'Y': f'{folder}/rubik_amarillo.jpg', 'W': f'{folder}/rubik_blanco.jpg', 'R': f'{folder}/rubik_rojo.jpg', 'O': f'{folder}/rubik_naranja.jpg', 'B': f'{folder}/rubik_azul.jpg', 'G': f'{folder}/rubik_verde.jpg', } print(" ------------ ESCANEANDO CUBO... ------------ ") cube = vision.RubiksCube(paths) print(cube) print(" ------------ RESOLVIENDO CUBO... ----------- ") solution_list = utils.solve(cube.to_solve_string(), 'Kociemba') solution_list = [str(move) for move in solution_list] solution_string = " ".join(solution_list) print(f'SOLUCIÓN: {solution_string}') print(f'{len(solution_list)}') # O B B # O Y B # R Y R # G Y W G G Y B O Y O Y Y # B B W G R B W G O G O R # O W W B Y G O W R Y R W # R R W # O W R
from rubik_solver import utils cube = 'wowgybwyogygybyoggrowbrgywrborwggybrbwororbwborgowryby' print(utils.solve(cube, 'Kociemba'))
string = get_color(i[0], i[1], df).split(" ") dic['color'].append(string[4]) if np.array_equal(color, bluec): blue = dic['color'] print("blue : ", blue) elif np.array_equal(color, redc): red = dic['color'] print("red : ", red) elif np.array_equal(color, yellowc): yellow = dic['color'] print("yellow : ", yellow) elif np.array_equal(color, greenc): green = dic['color'] print("green : ", green) elif np.array_equal(color, whitec): white = dic['color'] print("white : ", white) elif np.array_equal(color, orangec): orange = dic['color'] print("orange : ", orange) dic['pow'] = [] dic['color'] = [] cv2.imshow("ggwp", img) cv2.waitKey(0) cv2.destroyAllWindows() cube = yellow + blue + red + green + orange + white cube = ''.join(cube) utils.solve(cube, 'Beginner')
def kocem(cube): return u.solve(cube, 'Kociemba')
cube = 'wowgybwyogygybyoggrowbrgywrborwggybrbwororbwborgowryby' from rubik_solver import utils print("\nKociemba:\n {}".format(utils.solve(cube, 'Kociemba'))) ''' Kociemba solver needs the following cubies at place: 4 (Upper center): YELLOW 13 (Left center): BLUE 22 (Front center): RED 31 (Right center): GREEN 40 (Back center): ORANGE 49 (Down center): WHITE ---------------- | 0 | 1 | 2 | ---------------- | 3 | 4 | 5 | ---------------- | 6 | 7 | 8 | ---------------- ------------------------------------------------------------- | 9 | 10 | 11 | 18 | 19 | 20 | 27 | 28 | 29 | 36 | 37 | 38 | ------------------------------------------------------------- | 12 | 13 | 14 | 21 | 22 | 23 | 30 | 31 | 32 | 39 | 40 | 41 | ------------------------------------------------------------- | 15 | 16 | 17 | 24 | 25 | 26 | 33 | 34 | 35 | 42 | 43 | 44 | -------------------------------------------------------------
def cfop_new(cube): return u.solve(cube, 'CFOP')