def __init__(self, cube_size=2, block_size=None, start_pos=None, block_color=None, set_colors=True):
RubiksCube.__init__(self, cube_size, False)
BVCube.__init__(self, start_pos, cube_size)
BFps.__init__(self)
if block_size is None or block_size < 2:
self._block_size = 2
else:
self._block_size = block_size
if block_color is None:
self._block_color = color.gray(0.4)
else:
self._block_color = block_color
start_point = self._dimension*self._block_size/2
start_vector = self._pos - vector(start_point, start_point, start_point)
half_block = vector(self._block_size/2, self._block_size/2, self._block_size/2)
# generate all the cubes
for x in xrange(self._dimension):
for y in xrange(self._dimension):
for z in xrange(self._dimension):
current_vector = vector(self._block_size*x, self._block_size*y, self._block_size*z)
current_block_pos = start_vector + half_block + current_vector
self._array[x][y][z] = VCube(current_block_pos,self._block_color,self._block_size*2)
self.reset_array(set_colors)
def from_xml(xml_object, size):
rubikscube = RubiksCube(size)
for x in Helper.CUBE_SIDES:
side = [[None for k in xrange(size)] for i in xrange(size)]
for y in range(rubikscube.get_size()):
for z in range(rubikscube.get_size()):
value = xml_object.find(x+"/Part-"+str(y)+"-"+str(z)).text
if value == str(None):
side[y][z] = None
else:
side[y][z] = int(value)
rubikscube.set_side(x, side)
return rubikscube
def set_part(self, side, x, y, color, create_mode=False):
if create_mode:
RubiksCube.set_part(self, side, x, y, color)
else:
if side == "Front":
self._array[x][y][self._dimension-1].get_front().color = color
if side == "Back":
self._array[x][y][0].get_back().color = color
if side == "Top":
self._array[x][self._dimension-1][y].get_top().color = color
if side == "Bottom":
self._array[x][0][y].get_bottom().color = color
if side == "Left":
self._array[0][x][y].get_left().color = color
if side == "Right":
self._array[self._dimension-1][x][y].get_right().color = color
def to_code_cube(input_cube):
if input_cube.__class__ == RubiksCube().__class__:
return input_cube
cube = RubiksCube(input_cube.get_size(), False)
for side in Helper.CUBE_SIDES:
current_side = input_cube.get_side(side)
for x in range(input_cube.get_size()):
for y in range(input_cube.get_size()):
if current_side[x][y].color in Helper.CUBE_COLOR:
current_side[x][y] = Helper.CUBE_COLOR.index(current_side[x][y].color)
else:
current_side[x][y] = None
cube.set_side(side, current_side)
return cube
def filter_cube(self, input_cube, xml_cube):
temp_cube = RubiksCube(self.cube_size, False)
for side in Helper.CUBE_SIDES:
current_side = input_cube.get_side(side)
match_side = xml_cube.get_side(side)
new_side = []
for x in range(self.cube_size):
new_side.append([])
for y in range(self.cube_size):
if match_side[x][y] is None:
new_side[x].append(None)
else:
new_side[x].append(current_side[x][y])
temp_cube.set_side(side, new_side)
return temp_cube
def turn_x(self, index, direction):
for r in xrange(self.fps):
rate(self.rate)
for x in xrange(self._dimension):
for y in xrange(self._dimension):
if index >= 0:
self._array[index][x][y].rotate(self.degrees90/self.fps,
vector(direction*-1, 0, 0),
self._pos)
else:
for rows in range(self._dimension):
self._array[rows][x][y].rotate(self.degrees90/self.fps,
vector(direction*-1, 0, 0),
self._pos)
if index >= 0:
RubiksCube.turn_x(self, index, direction)
else:
for rows in range(self._dimension):
RubiksCube.turn_x(self, rows, direction)
for x in range(self.cube_size):
for y in range(self.cube_size):
if current_side[x][y] is not None:
current_side[x][y] = (current_side[x][y] + set_num) % 6
local_cube.set_side(side, current_side)
return local_cube
myXml = XmlParser()
myObject = myXml.read_file("2.1.xml", True)
myObject2 = myXml.read_file("xxx_cube.xml", True)
x = RubiksCube(3)
x2 = RubiksCube(3)
x2.turn_z(-1,1)
#RubiksCubeConverter.to_visual_cube(myObject._start_cube)
#RubiksCubeConverter.to_visual_cube(myObject2._start_cube)
main = PatternFinder(3)
#print main.find_pattern(x, x2)
print main.find_pattern(myObject2._start_cube, myObject._start_cube)
#print main.find_pattern(x, x2)
#print main.find_pattern(myObject._start_cube, myObject2._start_cube)
#for cube in mycubes:
