用Python简陋模拟n阶魔方

第用Python简陋模拟n阶魔方def__init__(self,order=3,size=50):#魔方阶数、显示尺寸

self.img=np.zeros((4*size*order,3*size*order,3),dtype=np.uint8)

self.order=order

self.size=size

self.len=size*order

self.top=[['y']*orderfor_inrange(order)]

self.front=[['r']*orderfor_inrange(order)]

self.left=[['b']*orderfor_inrange(order)]

self.right=[['g']*orderfor_inrange(order)]

self.back=[['o']*orderfor_inrange(order)]

self.bottom=[['w']*orderfor_inrange(order)]

self.axis_rotate=(self.base_rotate_x,self.base_rotate_y,self.base_rotate_z)

self.color={'y':(0,255,255),'r':(0,0,255),'b':(255,0,0),

'g':(0,255,0),'o':(0,128,255),'w':(255,255,255)}

defcheck(self):#检测魔方是否还原

foriinrange(self.order):

forjinrange(self.order):

ifself.top[i][j]!=self.top[0][0]:

returnFalse

ifself.back[i][j]!=self.back[0][0]:

returnFalse

ifself.front[i][j]!=self.front[0][0]:

returnFalse

ifself.left[i][j]!=self.left[0][0]:

returnFalse

ifself.right[i][j]!=self.right[0][0]:

returnFalse

ifself.bottom[i][j]!=self.bottom[0][0]:

returnFalse

returnTrue

defshow(self,wait=0):#显示魔方展开图

foriinrange(self.order):

forjinrange(self.order):

#back

x,y=self.len+i*self.size,j*self.size

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),self.color[self.back[j][i]],-1)

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),(10,10,10),1)

#left

x,y=i*self.size,self.len+j*self.size

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),self.color[self.left[j][i]],-1)

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),(10,10,10),1)

#top

x,y=self.len+i*self.size,self.len+j*self.size

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),self.color[self.top[j][i]],-1)

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),(10,10,10),1)

#right

x,y=2*self.len+i*self.size,self.len+j*self.size

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),self.color[self.right[j][i]],-1)

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),(10,10,10),1)

#front

x,y=self.len+i*self.size,2*self.len+j*self.size

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),self.color[self.front[j][i]],-1)

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),(10,10,10),1)

#bottom

x,y=self.len+i*self.size,3*self.len+j*self.size

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),self.color[self.bottom[j][i]],-1)

cv2.rectangle(self.img,(x,y),(x+self.size,y+self.size),(10,10,10),1)

cv2.imshow('cube',self.img)

cv2.waitKey(wait)

defshuffle(self,times):#打乱魔方

for_inrange(times):

self.rotate(randint(0,2),randint(0,self.order-1),randint(0,3))

defrotate(self,axis,index,times):#旋转魔方：axis轴，第index层，逆时针times次

for_inrange(times):

self.axis_rotate[axis](index)

defcount(self,color='y'):

count=0

foriinrange(self.order):

forjinrange(self.order):

ifself.top[i][j]==color:

count+=1

returncount

@staticmethod

def_column_trans(surface,index,col):

fori,rinenumerate(surface):

r[index]=col[i]

defbase_rotate_x(self,index):

ifindex==0:

self.left=[list(c)forcinzip(*self.left)][::-1]

elifindex==self.order-1:

self.right=[list(c)[::-1]forcinzip(*self.right)]

temp=[r[index]forrinself.top]

self._column_trans(self.top,index,[r[index]forrinself.front])

self._column_trans(self.front,index,[r[index]forrinself.bottom])

self._column_trans(self.bottom,index,[r[index]forrinself.back])

self._column_trans(self.back,index,temp)

defbase_rotate_y(self,index):

ifindex==0:

self.back=[list(c)[::-1]forcinzip(*self.back)]

elifindex==self.order-1:

self.front=[list(c)forcinzip(*self.front)][::-1]

temp=self.left[index][::-1]

self.left[index]=self.top[index]

self.top[index]=self.right[index]

self.right[index]=self.bottom[self.order-index-1][::-1]

self.bottom[self.order-index-1]=temp

defbase_rotate_z(self,index):

ifindex==0:

self.top=[list(c)forcinzip(*self.top)][::-1]

elifindex==self.order-1:

self.bottom=[list(c)[::-1]forcinzip(*self.bottom)]

temp=self.front[index][::-1]

self.front[index]=[r[self.order-i