def solve(state):
raw = ''
for i in state:
for j in state[i]:
raw += sign_conv[j]
print("answer:", Cube.solve(raw))
return Cube.solve(raw)
def main():
if len(sys.argv) == 2:
print(solve(sys.argv[1]))
elif len(sys.argv) == 3:
print(solve(sys.argv[1], sys.argv[2]))
else:
print('Usage: kociemba <cubestring> [resulting_cubestring]\nfor example:\nkociemba DRLUUBFBRBLURRLRUBLRDDFDLFUFUFFDBRDUBRUFLLFDDBFLUBLRBD BBURUDBFUFFFRRFUUFLULUFUDLRRDBBDBDBLUDDFLLRRBRLLLBRDDF')
def solve(config):
six_face = []
success = 0
solution = []
all_config = []
for i in range(6):
six_face.append(Counter(config[i]).most_common(1)[0][0])
for i_1 in range(4):
for i_2 in range(4):
for i_3 in range(4):
for i_4 in range(4):
for i_5 in range(4):
for i_6 in range(4):
problem = change(six_face[0], i_1) + change(
six_face[1], i_2) + change(
six_face[2], i_3) + change(
six_face[3], i_4) + change(
six_face[4], i_5) + change(
six_face[5], i_6)
#print(problem)
try:
solution = kociemba.solve(problem)
all_config.append(problem)
#print('adfgfd')
success += 1
except:
pass
#problem=six_face[0]+six_face[1]+six_face[2]+six_face[3]+six_face[4]+six_face[5]
try:
solution = kociemba.solve(problem)
success += 1
except:
pass
return solution, success, all_config
def main():
if len(sys.argv) == 2:
print(solve(sys.argv[1]))
elif len(sys.argv) == 3:
print(solve(sys.argv[1], sys.argv[2]))
else:
print(
'Usage: kociemba <cubestring> [resulting_cubestring]\nfor example:\nkociemba DRLUUBFBRBLURRLRUBLRDDFDLFUFUFFDBRDUBRUFLLFDDBFLUBLRBD BBURUDBFUFFFRRFUUFLULUFUDLRRDBBDBDBLUDDFLLRRBRLLLBRDDF'
)
def path(self, to=None):
algorithm = solve(str(self), str(
to)) if to is not None else solve(str(self))
steps = []
cube = Cube.from_iterable(str(self))
for move in algorithm.split(' '):
source = str(cube)
cube(move)
target = str(cube)
steps.append({
'source': source,
'target': target,
'move': move,
})
return algorithm, steps
def solve(self):
if not self.lock:
if not self.safe():
return
else:
clean.destroy(False,
[ui.solve_label,
ui.chrono_software,
ui.chrono_robot])
timer.start()
return_code = kociemba.solve(self.__get__())
timer.stop()
ui.solve_label = Label(ui.board_parent, text="» " + return_code, font=ui.mini_ui_font, bg='#000', fg='#00C000')
ui.solve_label.place(x=24, y=870)
text = "» The algorithm has solved the Rubik's cube in " + str(round(timer.interval, 3)) + " seconds with " + str(len(return_code.split())) + ' moves'
ui.chrono_software = Label(ui.board_parent, text=text, font=ui.mini_ui_font, bg='#000', fg='#FFFFFF')
ui.chrono_software.place(x=827, y=830)
timer.start()
# SEND_TO_ROBOT()
timer.stop()
ui.chrono_robot = Label(ui.board_parent, text="» The robot has solved the Rubik's cube in " + str(round(timer.interval, 3)) + " seconds", font=ui.mini_ui_font, bg="#000", fg="#FFFFFF")
ui.chrono_robot.place(x=827, y=850)
def solve(cube):
solution = kociemba.solve(cube.replace(' ', ''))
# solution = "L' B' U R' L U2 D2 F' R' B' D R2 U2 F2 L2 F2 U2 L2 U"
lists = solution.split(' ')
i = 0
while i <= len(lists) - 1:
if len(lists[i]) == 2:
if lists[i][1] == "'":
lists[i] = lists[i][0].lower()
else:
lists[i] = lists[i][0]
lists.insert(i, lists[i])
i += 1
str1 = ''.join(lists)
# str1 = str(lists).replace("'","")
#print(str1)
lists.reverse()
for i in range(len(lists)):
item = lists[i]
if item >= 'A' and item <= 'Z':
lists[i] = item.lower()
else:
lists[i] = item.upper()
str2 = ''.join(lists)
# str2 = str(lists).replace("'","")
#print(str2)
return str1, str2
def solve_fast(cube, max_depth=24):
assert isinstance(cube, pycuber.Cube)
coloring = str(cube).replace("[", "").replace("]", "").replace(" ", " ")
coloring = coloring.split("\n")
seq = coloring[0].strip() + coloring[1].strip() + coloring[2].strip()
seq += coloring[3][6:9]
seq += coloring[4][6:9]
seq += coloring[5][6:9]
seq += coloring[3][3:6]
seq += coloring[4][3:6]
seq += coloring[5][3:6]
seq += coloring[6][3:6]
seq += coloring[7][3:6]
seq += coloring[8][3:6]
seq += coloring[3][:3]
seq += coloring[4][:3]
seq += coloring[5][:3]
seq += coloring[3][9:12]
seq += coloring[4][9:12]
seq += coloring[5][9:12]
seq = seq.replace("y", "U")
seq = seq.replace("g", "F")
seq = seq.replace("w", "D")
seq = seq.replace("r", "L")
seq = seq.replace("o", "R")
seq = seq.replace("b", "B")
return kociemba.solve(seq, max_depth=max_depth)
def solve(self):
solution = None
try:
solution = kociemba.solve(str(self))
except:
pass
return solution
def solve1(sequence):
for i in range(len(sequence)):
Frequencies(sequence[i])
start_time = time.time()
#rgb = Camera_Activation()
#c = [' ']*rgb.shape[0]
# print c ############################
#color = [' ']*rgb.shape[0]
#Range(rgb,c,color)
#string = ''.join(c)
#print string
#string = string[:4] + 'U' + string[4:]
#string = string[:13] + 'R' + string[13:]
#string = string[:22] + 'F' + string[22:]
#string = string[:31] + 'D' + string[31:]
#string = string[:40] + 'L' + string[40:]
#string = string[:49] + 'B' + string[49:]
#print string
solve_moves = kociemba.solve(
'DRLUUBFBRBLURRLRUBLRDDFDLFUFUFFDBRDUBRUFLLFDDBFLUBLRBD')
#solve_moves = solve_moves.split(' ')
#Tkinter(color,solve_moves, 0,0)
for i in range(len(solve_moves)):
Frequencies(solve_moves[i])
end_time = time.time()
diff = (end_time - start_time)
Tkinter1(solve_moves, ("%.2f" % diff), 1)
def Done(self):
s = ["B", "U", "R", "F", "D", "L"]
cube = "UUUUUUUUURRRRRRRRRFFFFFFFFFDDDDDDDDDLLLLLLLLLBBBBBBBBB"
list1 = list(cube)
for j in range(0, 54):
list1[j] = s[self.i[j]]
cube = ''.join(list1)
s = kociemba.solve(cube)
print(s)
i = 0
s += ' '
while (i < len(s)):
if (s[i + 1] == ' '):
arduino.write(s[i].encode('utf-8'))
i += 2
elif (s[i + 1] == "'"):
arduino.write((s[i].lower()).encode('utf-8'))
i += 3
else:
if (s[i] == 'R'): arduino.write(b'1')
elif (s[i] == 'L'): arduino.write(b'2')
elif (s[i] == 'B'): arduino.write(b'3')
elif (s[i] == 'F'): arduino.write(b'4')
elif (s[i] == 'U'): arduino.write(b'5')
elif (s[i] == 'D'): arduino.write(b'6')
i += 3
sys.exit(app.exec_())
def rubik_cv():
"""
main code execution
"""
faces = detect_faces()
# To skip face color detection and use a preset uncoment the following lines and comment the preceding line.
# from color_enum import Color
# faces = [[[Color.WHITE, Color.WHITE, Color.WHITE], [Color.GREEN, Color.GREEN, Color.GREEN], [Color.GREEN, Color.GREEN, Color.GREEN]],
# [[Color.RED, Color.RED, Color.RED], [Color.RED, Color.RED,
# Color.RED], [Color.RED, Color.RED, Color.RED]],
# [[Color.YELLOW, Color.YELLOW, Color.YELLOW], [Color.BLUE,
# Color.BLUE, Color.BLUE], [Color.BLUE, Color.BLUE, Color.BLUE]],
# [[Color.ORANGE, Color.ORANGE, Color.ORANGE], [Color.ORANGE, Color.ORANGE,
# Color.ORANGE], [Color.ORANGE, Color.ORANGE, Color.ORANGE]],
# [[Color.BLUE, Color.BLUE, Color.BLUE], [Color.WHITE, Color.WHITE,
# Color.WHITE], [Color.WHITE, Color.WHITE, Color.WHITE]],
# [[Color.GREEN, Color.GREEN, Color.GREEN], [Color.YELLOW, Color.YELLOW, Color.YELLOW], [Color.YELLOW, Color.YELLOW, Color.YELLOW]]]
print(faces)
cube = reconstruct(faces)
print(cube)
solution = kociemba.solve(cube)
print(solution)
gl_app = OpenGLApp(solution)
gl_app.run()
def solve(scanner, motors):
"""scan the cube, get a solution from kociemba, then execute it on the robot."""
logging.info("Scanning...")
t0 = round(time.time() * 1000)
state_str = scanner.get_state_string(motors)
t1 = round(time.time() * 1000)
logging.info("Scanned state: " + state_str)
time.sleep(1)
logging.info("Solving...")
t2 = round(time.time() * 1000)
solution = kociemba.solve(state_str)
t3 = round(time.time() * 1000)
logging.info("Solution: " + solution)
logging.info("Executing...\n")
t4 = round(time.time() * 1000)
motors.execute(solution)
t5 = round(time.time() * 1000)
logging.info('Scan time: {:d}ms'.format(t1 - t0))
logging.info('Solve time: {:d}ms'.format(t3 - t2))
logging.info('Execution time: {:d}ms'.format(t5 - t4))
return(0)
def run(self):
state = webcam.scan()
if not state:
print('Solver Error, you didnt scan the 6 sides of the cube.')
print('Make sure you scan all faces of the cube please')
print('try again')
nelxd(1)
unsolved = combine.sides(state)
try:
solution = kociemba.solve(unsolved)
length = len(solution.split(' '))
except Exception as err:
print('Solver Error, you didnt scan the 6 sides of the cube.')
print('Make sure you scan all faces of the cube please')
print('try again')
nelxd(1)
print('=================== S O L U T I O N ===================')
print(
'Starting position \n FRONT: GREEN MIDDLE CUBIE /n TOP: WHITE MIDDLE CUBIE'
)
print(solution, '({0} moves)'.format(length), '\n')
if self.ezsolve:
handmade = normalize.algorithm(solution, self.language)
for index, text in enumerate(handmade):
print('{}. {}'.format(index + 1, text))
nelxd(0)
def main():
if len(sys.argv) > 1:
print(solve(sys.argv[1]))
else:
print(
'Usage: kociemba <cubestring>\nfor example:\nkociemba DRLUUBFBRBLURRLRUBLRDDFDLFUFUFFDBRDUBRUFLLFDDBFLUBLRBD'
)
def solve(self):
"""utiliza el metodo de kociemba para obtener la solucion"""
kociemba_sequence = self.kociemba_state()
solution = kociemba.solve(kociemba_sequence)
self.mov_sq(solution)
return solution
def run(self):
state = webcam.scan()
if not state:
print('\033[0;33m[QBR SCAN ERROR] Ops, you did not scan in all 6 sides.')
print('Please try again.\033[0m')
Die(1)
unsolvedState = combine.sides(state)
try:
algorithm = kociemba.solve(unsolvedState)
length = len(algorithm.split(' '))
except Exception as err:
print('\033[0;33m[QBR SOLVE ERROR] Ops, you did not scan in all 6 sides correctly.')
print('Please try again.\033[0m')
Die(1)
print('-- SOLUTION --')
print('Starting position:\n front: green\n top: white\n')
print(algorithm, '({0} moves)'.format(length), '\n')
if self.humanize:
manual = normalize.algorithm(algorithm, self.language)
for index, text in enumerate(manual):
print('{}. {}'.format(index+1, text))
Die(0)
def __generate_handwritten_solution_from_cube_state(
self, cube_centers, rubiks_labels):
"""
Generate movement solution for the robot's arms. This method returns the sequence of
steps required for the robot to solve the cube.
:param cube_centers: A 6-element list containing the numeric labels for each face's center.
:param rubiks_labels: Flattened Rubik's cube labels in the order expected by the muodov/kociemba library.
These labels are numeric.
:return:
"""
# generate dictionary to map between center labels as
# digits to labels as a handwritten notation: URFDLB
kociembas_input_labels = {}
for center, label in zip(cube_centers, 'U R F D L B'.split()):
kociembas_input_labels[center] = label
# generate the cube's state as a list of strings of 6x9 labels
cubestate = [kociembas_input_labels[label] for label in rubiks_labels]
cubestate = ''.join(cubestate)
# generate the solution for the given cube's state
solved = kociemba.solve(cubestate)
solved = solved.split(' ')
return solved
def generateSolution(self):
"""
Generate a solution for the current cubestring and display in the GUI
"""
self.statusbar.showMessage("Generating Solution")
msg = "Generating solution for cubestring: " + self.cube.cubestring
self.addLogEntry(msg)
timer = QElapsedTimer()
timer.start()
solution = "No Solution"
try:
solution = kociemba.solve(self.cube.cubestring)
except Exception as err:
print(err)
error_dialog = QErrorMessage()
error_dialog.showMessage(err.args[0])
error_dialog.exec_()
solution = err.args[0]
self.statusbar.showMessage("Solution generation failed!")
msg = "Solution could not be calculated: " + solution
self.addLogEntry(msg)
self.lineEdit_InOut.setText(solution)
self.label_CurrentString.setText("Solution:")
self.statusbar.showMessage("Generated Solution")
msg = "Solution calculation took: {} ms".format(timer.nsecsElapsed() /
1000000)
self.addLogEntry(msg)
# self.timer1ms.stop()
pass
def solve(message):
f = open('log.txt', 'a')
f.write('\n {}: {} -> {} \n'.format(str(datetime.datetime.now()), message.chat.username, message.text))
f.close()
data = message.text.split()[-1].upper()
for old, new in ((data[4], 'U'), (data[22], 'F'), (data[40], 'L'), (data[13], 'R'), (data[49], 'B'), (data[31], 'D')):
data = data.replace(old, new)
if 'U' and 'R' and 'F' and 'D' and 'L' and 'B' in list(data) and len(data) == 54:
out = kociemba.solve(data)
bot.reply_to(message, out, reply_markup=markup)
for item in out.split():
f = open('./kubik/{}.jpg'.format(item), 'rb')
bot.send_photo(message.chat.id, f)
bot.reply_to(message, str(len(out.split()))+' steps')
botan.track(config.botan_key, message.chat.id, message, 'color-solve')
else:
if len(data) > 54:
bot.reply_to(message, 'Введены неверные входные данные: Строка содержит > 54 символов',
reply_markup=markup)
elif len(data) < 54:
bot.reply_to(message, 'Введены неверные входные данные: Строка содержит < 54 символов',
reply_markup=markup)
else:
bot.reply_to(message, 'Введены неверные входные данные: Должно быть {W, B, R, O, G, Y}',
reply_markup=markup)
def get_moves_to_random_state(self):
"""
获得从魔方的初始状态到任意状态的解法步骤
:return: 返回步骤字符串
"""
return kociemba.solve(self.SOLVED_STATE, self.string)
def solve_interactive(scanner, motors):
"""scan the cube, get a solution from kociemba, then execute it on the robot."""
input("Press any key to begin scanning the cube.")
t0 = round(time.time() * 1000)
state_str = scanner.get_state_string(motors)
t1 = round(time.time() * 1000)
logging.info("Scan complete! Cube state: {0}\n".format(state_str))
input("Press any key to generate the solution.")
t2 = round(time.time() * 1000)
solution = kociemba.solve(state_str)
t3 = round(time.time() * 1000)
logging.info("Finished solving! Solution: {0}\n".format(solution))
input("Press any key to execute the solution.")
t4 = round(time.time() * 1000)
motors.execute(solution)
t5 = round(time.time() * 1000)
logging.info('Scan time: {:d}ms'.format(t1 - t0))
logging.info('Solve time: {:d}ms'.format(t3 - t2))
logging.info('Execution time: {:d}ms'.format(t5 - t4))
return(0)
def solve(self):
"""
kociemba算法解魔方
:return: 返回步骤字符串
"""
return kociemba.solve(self.string)
def sol(input1):
input2 = [[[]], [[]], [[]], [[]], [[]], [[]]]
for i in range(6):
if (input1[i][1][1] == 'Y'):
input2[0] = input1[i]
break
for i in range(6):
if (input1[i][1][1] == 'O'):
input2[1] = input1[i]
break
for i in range(6):
if (input1[i][1][1] == 'G'):
input2[2] = input1[i]
break
for i in range(6):
if (input1[i][1][1] == 'W'):
input2[3] = input1[i]
break
for i in range(6):
if (input1[i][1][1] == 'R'):
input2[4] = input1[i]
break
for i in range(6):
if (input1[i][1][1] == 'B'):
input2[5] = input1[i]
break
for i in range(6):
for j in range(3):
for k in range(3):
if (input2[i][j][k] == 'Y'):
input2[i][j][k] = 'U'
elif (input2[i][j][k] == 'W'):
input2[i][j][k] = 'D'
elif (input2[i][j][k] == 'O'):
input2[i][j][k] = 'R'
elif (input2[i][j][k] == 'R'):
input2[i][j][k] = 'L'
elif (input2[i][j][k] == 'G'):
input2[i][j][k] = 'F'
elif (input2[i][j][k] == 'B'):
input2[i][j][k] = 'B'
b = ''
for i in range(6):
for j in range(3):
for k in range(3):
b += input2[i][j][k]
a = kociemba.solve(b)
a = a.replace("U", "R L F2 B2 R' L' D R L F2 B2 R' L'")
a = a.replace("U'", "R L F2 B2 R' L' D' R L F2 B2 R' L'")
a = a.replace("U2", "R L F2 B2 R' L' D2 R L F2 B2 R' L'")
return a
def main():
cube_state.clear()
parser = argparse.ArgumentParser()
parser.add_argument('-i',
'--images',
default=os.getcwd() + '/images-main2/',
help='File path to images folder')
args = parser.parse_args()
image_folder = args.images
img_number = 1
for filename in sorted(os.listdir(image_folder)):
if filename.endswith(".jpeg") or filename.endswith(
".jpg") or filename.endswith(".png"):
path = os.path.join(image_folder, filename)
face_state = detectColors(path, img_number)
cube_state.extend(face_state)
img_number += 1
kociemba_string = getKociembaString(cube_state)
# key = cv2.waitKey() & 0xFF
# if key == ord('q'):
# cv2.destroyAllWindows()
if (len(kociemba_string) != 54):
print("Incorrect length for Kociemba input")
print(kc.solve('RRBBUFBFBRLRRRFRDDURUBFBBRFLUDUDFLLFFLLLLDFBDDDUUBDLUU'))
def run(self):
state = webcam.scan()
if not state:
print(
'\033[0;33m[QBR SCAN ERROR] Ops, you did not scan in all 6 sides.'
)
print('Please try again.\033[0m')
Die(1)
unsolvedState = combine.sides(state)
try:
algorithm = kociemba.solve(unsolvedState)
length = len(algorithm.split(' '))
except Exception as err:
print(
'\033[0;33m[QBR SOLVE ERROR] Ops, you did not scan in all 6 sides correctly.'
)
print('Please try again.\033[0m')
Die(1)
print('-- SOLUTION --')
print('Starting position:\n front: green\n top: white\n')
print(algorithm, '({0} moves)'.format(length), '\n')
# if self.humanize:
manual = normalize.algorithm(algorithm, self.language)
for index, text in enumerate(manual):
print('{}. {}'.format(index + 1, text))
Die(0)
def talker():
pub = rospy.Publisher('chatter', String, queue_size=10)
rospy.init_node('cubot', anonymous=True)
rate = rospy.Rate(10)
msg_str = ""
i = 0
while (True):
i += 1
if i == 20:
i == 0
r = requests.get(solve_url)
# detected the file
if r.status_code == 200:
msg_str = str(r.content)
# trigger to delete
# requests.get(delete_url)
break
else:
print "trying to read the file ... "
break
#msg_str = "DRLUUBFBRBLURRLRUBLRDDFDLFUFUFFDBRDUBRUFLLFDDBFLUBLRBD"
print msg_str
res_str = kociemba.solve(msg_str)
list_ = res_str.split(" ")
after_proc_str = ""
for a in list_:
after_proc_str += dict[a]
#after_proc_str += ' '
print after_proc_str
# broadcast in ROS
while not rospy.is_shutdown():
rospy.loginfo(after_proc_str)
pub.publish(after_proc_str)
rate.sleep()
def startSol():
'''Inicialización de todas las variables necesarias, antiguio main del archivo. Se hizo función para llamarla desde sendSolution'''
cube = getCube()
stdSol = kociemba.solve(cube)
sol = ''.join(stdSol.split())
filteredSolve = sol
config.fSolve = areTwoOrPrime(filteredSolve)
config.listSol = list(config.fSolve)
def solve(cube):
unsolved_cube = ""
for face in cube:
for piece in cube[face]:
unsolved_cube += Face_Assignment[piece]
step_by_step_solution = kociemba.solve(unsolved_cube)
print("Steps to Solve cube : ", step_by_step_solution)
return step_by_step_solution
def compute_solution(self, state, callback=None):
if state == RubiksCube.SOLVED_STR:
self._solution = []
else:
solution = kociemba.solve(state).split(" ")
self._solution = solution
if callback is not None:
callback(self._solution)
def solve_cube(self):
str = self.white_str + self.red_str + self.green_str + self.yellow_str + self.orange_str + self.blue_str
self.sollution = kociemba.solve(str)
self.sollution = self.sollution.split(" ")
self.solve_status = True
print(self.sollution)
self.next = Button(self.root, text ="step",width=15,height=1, command = self.step,bg="#DCDCDC")
self.next.place(x=770,y=510,in_=self.root)
def add_task(self, cube):
if self.server is not None:
self.display = True
faces = self.revert_faces(cube)
if self.display:
self.display_task(faces)
steps = kociemba.solve(cube)
self.execute_steps(steps)
def calculate(data):
seq_raw = solve(data)
seq_new = []
for seq in seq_raw.split(" "):
if len(seq)==1:
seq_new.append(seq)
else:
if seq[1]=="'":
seq_new.append(seq[0].lower())
else:
seq_new.extend([seq[0],seq[0]])
return seq_new
return side_sequence
def calibrate():
t = 0
while t < 6:
ser.write("set value")
k = 0
while (k == 0):
k = input("press '0' to start motor " + str(t) + " : ")
while True:
side_sequence = getCube()
print "cube : ", side_sequence
try:
solve = kociemba.solve(side_sequence)
break
except:
print "Error in cube, please re-scan"
solve = solve + " "
print solve
k = 0
calibrate()
while k == 1:
k = input("Start solving ? :")
ser.write(solve.encode('ascii', 'ignore'))
cv2.destroyAllWindows()
def test_solve_function(input, expected):
assert solve(input) == expected
def main():
if len(sys.argv) > 1:
print(solve(sys.argv[1]))
else:
print('Usage: kociemba <cubestring>\nfor example:\nkociemba DRLUUBFBRBLURRLRUBLRDDFDLFUFUFFDBRDUBRUFLLFDDBFLUBLRBD')
],
)
def test_solve_function(input, expected):
assert solve(input) == expected
if __name__ == "__main__":
import sys
import logging
logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
if len(sys.argv) > 1:
fname = sys.argv[1]
logging.info("loading tests from %s", fname)
with open(fname, "rb") as f:
cnt = 0
t = f.readline()
while t:
logging.info("running test %d..." % (cnt + 1))
t = t.strip()
r = f.readline().strip()
res = solve(t)
if res != r:
logging.error("Error for %s:\n\tmust be: %s\n\tgot: %s" % (t, repr(r), repr(res)))
sys.exit(1)
cnt += 1
t = f.readline()
logging.info("all %d tests passed" % cnt)
else:
logging.error("Usage: %s <testfile.txt>", sys.argv[0])
def test_solve_pattern_function(input, pattern, expected):
assert solve(input, pattern) == expected
def solve(cube_str):
return kociemba.solve(cube_str)
