def __init__(self, s, d):
#Attributes
self.NumX = s
self.SizeOfSquare = d
#Once we have the size of the cube we need to make the individual
#Cubes so we need a triple for loop around NumX
self.Cubes = []
#Position of cube is (idx*SizeOfSquare - sizeOfSquare
for idx in range(0, self.NumX):
x = idx * self.SizeOfSquare - (
(self.NumX - 1) / 2.0) * self.SizeOfSquare
#Reset the layers
self.layer = []
for jdx in range(0, self.NumX):
y = jdx * self.SizeOfSquare - (
(self.NumX - 1) / 2.0) * self.SizeOfSquare
#Reset the columns
self.col = []
for kdx in range(0, self.NumX):
z = kdx * self.SizeOfSquare - (
(self.NumX - 1) / 2.0) * self.SizeOfSquare
newCube = Cube(x, y, z, self.SizeOfSquare)
#Append each Cube to a Column
self.col.append(newCube)
#print x,y,z
#Append Each Column to a Layer
#print self.col
self.layer.append(self.col)
#Append each layer to the array of Cubes
self.Cubes.append(self.layer)
if self.NumX == 1:
self.Cubes = [[[Cube(0, 0, 0, self.SizeOfSquare)]]]
def main():
randy = Renderer()
polyCube = Cube()
polyCube.build_polygon_mesh()
randy.render(polyCube.mesh, 512, "polyCube.jpg")
triangleCube = Cube()
triangleCube.build_triangle_mesh(4000)
randy.render(triangleCube.mesh, 1080, "HDcube.jpg")
polyCylinder = Cylinder()
polyCylinder.build_polygon_mesh()
randy.render(polyCylinder.mesh, 512, "polyCylinder.jpg")
triangleCylinder = Cylinder()
triangleCylinder.build_triangle_mesh(4000)
randy.render(triangleCylinder.mesh, 1080, "HDcylinder.jpg")
polySphere = Sphere()
polySphere.build_polygon_mesh()
randy.render(polySphere.mesh, 512, "polySphere")
triangleSphere = Sphere()
triangleSphere.build_triangle_mesh(4000)
randy.render(triangleSphere.mesh, 1080, "HDSphere")
def CubingOnUp():
cube_1_obj = Cube.Cube(cube_1)
cube_2_obj = Cube.Cube(cube_2)
cube_3_obj = Cube.Cube(cube_3)
cube_4_obj = Cube.Cube(cube_4)
cube_list = [cube_1_obj, cube_2_obj, cube_3_obj, cube_4_obj]
cube_stack = CubeStack.CubeStack(cube_list)
print(cube_stack.validate_stack())
print(cube_stack)
'''
Randomly pick a Cube from the CubeStack
Either rotate it left or clockwise
Check if it is a valid stack
'''
counter = 0
#while( not cube_stack.validate_stack() and counter < 1000000 ):
while (counter < 10000000):
counter = counter + 1
if counter % 100000 == 0:
print(counter)
idx = random.randint(0, len(cube_stack.stack) - 1)
if random.getrandbits(1):
cube_stack.stack[idx].rotate_left()
else:
cube_stack.stack[idx].rotate_clockwise()
if cube_stack.validate_stack():
print(cube_stack.validate_stack())
print(cube_stack)
def __init__(self, pos):
self.body = []
self.head = Cube.Cube(pos)
self.body.append(self.head)
body1 = Cube.Cube((self.head.pos[0]+1, self.head.pos[1]))
self.body.append(body1)
body2 = Cube.Cube((self.head.pos[0] + 2, self.head.pos[1]))
self.body.append(body2)
self.direction = (-1, 0)
def scrambler(n):
algor_list = []
algor = alg(algor_list, n)
cube = Cube.Cube()
for x in algor_list:
if x[1] == " ":
repeat = 1
elif x[1] == "2":
repeat = 2
elif x[1] == "'":
repeat = 3
for i in range(repeat):
if x[0] == "R":
cube.r()
elif x[0] == "L":
cube.l()
elif x[0] == "U":
cube.u()
elif x[0] == "D":
cube.d()
elif x[0] == "F":
cube.f()
else:
cube.b()
#print (str(cube))
image_output.image(str(cube), algor)
def parseState(message_array):
system_time = message_array[0]
if system_time == lasttime: return
message = np.delete(message_array.flatten(), 0)
length = message.shape[0]
nrows = int(length / 8)
if length % nrows != 0:
print "Error cant reshape"
return
message = message.reshape(nrows, 8)
for row_id in nrows:
row = message[row_id]
cube_id = row[0]
if cube_id not in cubes.keys():
cubes[cube_id] = Cube(cube_id)
faceup = row[1] - 1 #1-6 or 0-5
sensors = row[2:]
# is this the truth table i want or sensors>
sensors = sensors < ambient_threshold
cube = cubes[cube_id]
cube.setMostRecentFaceUp(faceup)
cube.setMostRecentLightSensorState(sensors)
lasttime = system_time
def main():
pygame.init()
screen = pygame.display.set_mode((800,600), DOUBLEBUF|OPENGL)
pygame.display.set_caption('OpenGL Cube Exemple')
gluPerspective(45, (800/600), 0.1, 50.0)
glTranslatef(0.0, 0.0, -10)
glRotatef(25, 1, -1, 0)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
glTranslatef(-0.5, 0, 0)
if event.key == pygame.K_RIGHT:
glTranslatef(0.5, 0, 0)
if event.key == pygame.K_UP:
glTranslatef(0, 0.5, 0)
if event.key == pygame.K_DOWN:
glTranslatef(0, -0.5, 0)
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 4:
glTranslatef(0, 0, 1.0)
if event.button == 5:
glTranslatef(0, 0, -1.0)
glRotatef(1, 3, 1, 1)
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
Cube.Cube()
pygame.display.flip()
def solve(self, timeout=float('inf')):
start_time = time.time()
start_state = State(self.cube, None, 0, 0, None)
goal_state = State(Cube(self.cube.size), None, 0, 0, None)
explored = set()
fringe = [start_state]
heapq.heapify(fringe)
#print("starting solve")
while len(fringe) > 0:
# Check to see if AI is timed out
if time.time() - start_time >= timeout:
print('time: ' + str(time.time()))
raise Exception('Code timed out')
current_state = heapq.heappop(fringe)
#print(current_state)
if current_state.current_state.isSolved():
return self.find_path(start_state, current_state)
if current_state.__hash__() in explored:
continue
for i in current_state.current_state.children('2x'):
if i.__hash__() not in explored:
new_addition = State(i[1], current_state, current_state.depth+1+self.heuristic(i[1]), current_state.depth+1, i[0])
heapq.heappush(fringe, new_addition)
explored.add(current_state.__hash__())
def main_repo(repo):
c = Cube()
randomize(c, 100)
print c
solver = AidedEntropicSolver(c, BasicEntropyEstimator(), repo)
solver.solve()
print c
class Debug:
cube = Cube(2)
move_list = []
def __init__(self):
pass
@staticmethod
def view(hash):
if hash == None:
return
m = Cube(2)
m.state = Cube.decode(hash)
g = GUI(cube=m, player=True, width=800, height=600)
while True:
g.update()
@staticmethod
def reset(cube=Cube(2)):
Debug.cube = cube
Debug.move_list = [((None, None), cube.__hash__())]
@staticmethod
def addMove(move):
Debug.move_list.append(move)
@staticmethod
def viewMoves():
g = GUI(cube=Debug.cube, width=800, height=600)
g.moveList(Debug.move_list)
while True:
g.update()
def scrambler(n):
algor_list = alg(n)
cube = Cube.Cube()
for x in algor_list:
if x[1] == " ":
repeat = 1
elif x[1] == "2":
repeat = 2
elif x[1] == "'":
repeat = 3
for i in range(repeat):
if x[0] == "R":
cube.r()
elif x[0] == "L":
cube.l()
elif x[0] == "U":
cube.u()
elif x[0] == "D":
cube.d()
elif x[0] == "F":
cube.f()
else:
cube.b()
print cube
def main():
c = Cube()
randomize(c, 3)
print c
solver = EntropicSolver(c, BasicEntropyEstimator())
solver.solve()
print c
def chargerEnv(nomfichier):
"""Fonction de chargement, ouverture du fichier en mode lecture"""
with open(nomfichier, 'r') as f:
liste_cube = list()
liste_robot = list()
"""deux listes vides pour contenir les objets charges"""
for line in f:
ligne = line.split(";")
if ligne[0] == 'Arene':
"""On cree une nouvelle arene avec les parametres trouves sur la ligne, separes par des ';' """
arene = Arene(int(ligne[1]), int(ligne[2]), int(ligne[3]),
liste_cube)
arene.liste_robot = liste_robot
elif ligne[0] == 'Cube':
"""On ajoute le cube a la liste de cube de l'arene, avec parametres trouves sur la ligne"""
arene.liste_cube.append(
Cube(int(ligne[1]), int(ligne[2]), int(ligne[3]),
int(ligne[4]), int(ligne[5]), int(ligne[6])))
elif ligne[0] == 'Mur':
arene.liste_cube.append(
Mur(int(ligne[1]), int(ligne[2]), int(ligne[3]),
int(ligne[4]), int(ligne[5]), int(ligne[6])))
elif ligne[0] == 'Sol':
arene.liste_cube.append(
Sol(int(ligne[1]), int(ligne[2]), int(ligne[3]),
int(ligne[4]), int(ligne[5])))
elif ligne[0] == 'Robot':
(x, y, z) = literal_eval(ligne[1])
(a, b, c) = literal_eval(ligne[2])
(lo, la, ha) = literal_eval(ligne[3])
arene.liste_robot.append(
Robot((x, y, z), (a, b, c), (lo, la, ha)))
print("Arene chargée.")
return arene
class CubicalComplex(Complex):
__init__(self, signatures):
dim=len(signatures[0])
cubes=[{} for i in range(dim+1)]
for sig in signatures:
if not sig in cubes[get_sig_dim(sig)]:
cubes[get_sig_dim(sig)][sig]=Cube(sig,cubes)
Complex.__init__(self,cubes.values())
def hammingDistance(cube):
current_state = cube.state
goal_state = Cube(cube.size).state
score = 6
for i in range(6):
if current_state[i] == goal_state[i]:
score -= 1
return score
def game_loop(game):
# TODO - create cubes
matrix = game.get_matrix()
game_cubes = []
for row in matrix:
for letter in row:
cube = Cube(letter)
game_cubes.append(cube)
def view(hash):
if hash == None:
return
m = Cube(2)
m.state = Cube.decode(hash)
g = GUI(cube=m, player=True, width=800, height=600)
while True:
g.update()
def __init__(self):
#initial cube object created upon initialization of CuBot object (54mm width, 3x3)
self.cube = Cube.Cube(54, 3)
#initialize self.arms object with all 3 self.arms (9 servos)
self.arms = Arms2.AllArms(self.cube)
self.leftArm = self.arms.leftArm
self.rightArm = self.arms.rightArm
self.centerArm = self.arms.centerArm
def getBox(w,h,d,x,y,z,string):
glPushMatrix()
glColor3f(1, 1, 1)
glTranslatef(x, y, z)
glActiveTexture(GL_TEXTURE0)
LoadTextures(string)
Cube(w, h, d)
glPopMatrix()
glDisable(GL_TEXTURE_2D)
return x-w,x+w,z-d,z+d
def __init__(self):
cubeface = CubeFaces(Cube_1)
cubeface.init_all_faces()
self.cube = Cube.Cube(cubeface.faces)
self.grids = [Grid("UP", cubeface.faces[UP], self.pos_grid[UP]),
Grid("FRONT", cubeface.faces[FRONT], self.pos_grid[FRONT]),
Grid("RIGHT", cubeface.faces[RIGHT], self.pos_grid[RIGHT]),
Grid("BACK", cubeface.faces[BACK], self.pos_grid[BACK]),
Grid("LEFT", cubeface.faces[LEFT], self.pos_grid[LEFT]),
Grid("DOWN", cubeface.faces[DOWN], self.pos_grid[DOWN])]
def __init__(self, r, c, w, h, window):
self.rows = r
self.cols = c
self.cubes = [[Cube(self.board[i][j], i, j, w, h) for j in range(c)]
for i in range(r)]
self.width = w
self.height = h
self.model = None
self.update_model()
self.selected = None
self.win = window
def Cube():
window.destroy()
import Cube
print("""\n\n\n\nGavin presents Cube!\nClick on the pile to update the card.
Press a to see how many cards are in the piles.""")
for i in range(1,4):
pygame.init()
#pygame.font.init()
cards = Cube.CubeCards(r=i)
Cube.Cube(cards)
print("\n\n\n\n\n")
def main():
print "Rubik's Cube scrambler by Ching, input the length of random algorithm you want and the resulting cube will be shown\nThis scrambler assume the use of Western color sheme with white face to the top and blue to the player"
cube2 = Cube.Cube()
print "Basic orientation:"
print cube2
moves = input(
"Please input the number of steps you want the crambler to have: ")
print "For the meaning of algorithm, please refer to: \nhttp://w.astro.berkeley.edu/~converse/rubiks.php?id1=basics&id2=notation"
scrambler(moves)
def main():
pygame.init()
windowScale = 1
display = (int(1920 * windowScale), int(1080 * windowScale))
pygame.display.set_mode(display, DOUBLEBUF | OPENGL)
gluPerspective(25, (display[0] / display[1]), 0.0, 50.0)
# glTranslatef(0, 0.0, -5)
cam = Camera()
cam.setPosition(0, 0, 10)
glRotatef(0, 0, 0, 0)
myStream = VisStream.VisStream(rate=48000 * 2, chunkSize=2**11)
cube = Cube.Cube()
# sheet = Sheet.Sheet()
while True:
glRotatef(myStream.getDynamicRotation(.0001, 50, 150), 3, 1, 1)
# glRotatef(1, 1, 0, 0)
# cam.setPosition(0, 0, -1*myStream.getDynamicRotation(5, 15, 150))
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
cube.setSideColors(myStream.getSideColors())
cube.draw()
# sheet.draw()
cs = myStream.getDynamicRotation(1, 1.5, 100)
cube.scaleCorner(scalars=[cs, cs, cs, cs, cs, cs, cs, cs])
pygame.display.flip()
pygame.time.wait(10)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
myStream.endStream()
quit()
if event.type == pygame.KEYUP:
if event.key == pygame.K_f:
myStream.plotStream()
if event.key == pygame.K_r:
myStream.reset()
if event.key == pygame.K_p:
gluPerspective(myStream.getDynamicRotation(45, 90, 150),
(display[0] / display[1]), 0.0, 50.0)
if event.key == pygame.K_DOWN:
cam.move(0, -1, 0)
if event.key == pygame.K_UP:
cam.move(0, 1, 0)
if event.key == pygame.K_LEFT:
cam.move(-1, 0, 0)
if event.key == pygame.K_RIGHT:
cam.move(1, 0, 0)
def solve(self, timeout=float('inf')):
start_time = time.time()
goal_state = Cube(self.cube.size).__hash__()
depth = 0
if self.cube.__hash__() == goal_state:
print('Found goal at depth ' + str(depth))
return [(None, self.cube)]
seen = {}
seen[self.cube.__hash__()] = (
self.cube, None, None, -1
) #Current cube, parent cube, move from parent to current, move from parent of parent to parent
fringe = {}
fringe[self.cube.__hash__()] = (self.cube, None, None, -1)
while True:
if time.time() - start_time >= timeout:
print('time: ' + str(time.time()))
raise Exception('Code timed out')
depth += 1
print('Depth: ' + str(depth) + ', length of fringe: ' +
str(len(fringe)) + '; len seen: ' + str(len(seen)))
print('time: ' + str(time.time()) + '; overlaped time: ' +
str(time.time() - start_time))
new_fringe = {}
for i in fringe:
if time.time() - start_time >= timeout:
print('time: ' + str(time.time()))
raise Exception('Code timed out')
for j in fringe[i][0].children('2x'):
if j[1].__hash__() == goal_state:
print('Found goal at depth ' + str(depth))
return self.find_path(seen,
(j[1], fringe[i][0], j[0], -1))
if j[0][0] == fringe[i][3]:
continue
if j[1].__hash__() not in fringe and j[1].__hash__(
) not in seen:
new_fringe[j[1].__hash__()] = (j[1], fringe[i][0],
j[0], j[0][0])
seen[j[1].__hash__()] = (j[1], fringe[i][0], j[0],
j[0][0])
fringe = new_fringe
def main():
display = (800, 600)
window = init(display)
cube_length = 10
#inicia instancias de Física e esferas
physics = Physics(cube_length)
list_spheres = create_spheres(physics, 25, 1, 20, 10)
timeA = glfw.get_time()
print_timer = 0.0
while not glfw.window_should_close(window):
timeB = glfw.get_time()
dt = timeB - timeA
timeA = timeB
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
Cube(cube_length)
physics.update()
for sphere in list_spheres:
sphere.update(dt)
for sphere in list_spheres:
sphere.rend()
#imprime informações sobre conservação
print_timer += dt
if print_timer > 1.0:
kinetic_energy = 0.0
for sphere in list_spheres:
kinetic_energy += float(sphere.velocity.norm() ** 2)#assumimos a massa como sendo uma unidade e nao dividimos por 2 para economizar processamento
print("Total kinetic energy: {}\n".format(kinetic_energy), end = '\r')
print_timer = 0.0
glfw.swap_buffers(window)
glfw.poll_events()
glfw.swap_interval(1);
end(window)
quit()
def create_repo(filename, depth=4):
repository = {}
depth = 5
basic_moves = []
for f in xrange(6):
for n in xrange(1, 4):
basic_moves.append((f, n))
for i, moves in enumerate(product(basic_moves, repeat=depth)):
c = Cube()
for move in moves:
c.rotate(*move)
t = c.get_current_tuple_representation()
repository.setdefault(t, moves)
print i
f = open('repo.dat', 'w')
cPickle.dump(repository, f)
f.close()
return repository
def solve(self, timeout=float('inf')):
start_time = time.time()
goal_state = Cube(self.cube.size).__hash__()
depth = 0
if self.cube.__hash__() == goal_state:
#print('Found goal at depth ' + str(depth))
return [(None, self.cube)]
# Remembers every state seen and allows us to find the parent state of a cube so we can output the path
seen = {}
seen[self.cube.__hash__()] = (self.cube, None, None, -1) #Current cube, parent cube, move from parent to current, move from parent of parent to parent
# The nodes that need to be expanded (the deepest lay)
fringe = {}
fringe[self.cube.__hash__()] = (self.cube, None, None, -1)
while True:
# Check to see if AI is timed out
if time.time() - start_time >= timeout:
print('time: ' + str(time.time()))
raise Exception('Code timed out')
depth += 1
#print('Depth: ' + str(depth) + ', length of fringe: ' + str(len(fringe)) + '; len seen: ' + str(len(seen)))
#print('time: ' + str(time.time()) + '; overlaped time: ' + str(time.time()-start_time))
new_fringe = {}
for i in fringe:
# Check to see if AI is timed out
if time.time() - start_time >= timeout:
print('time: ' + str(time.time()))
raise Exception('Code timed out')
for j in fringe[i][0].children('2x'):
if j[1].__hash__() == goal_state:
#print('Found goal at depth ' + str(depth))
return self.find_path(seen, (j[1], fringe[i][0], j[0], -1))
if j[0][0] == fringe[i][3]:
continue
if j[1].__hash__() not in fringe and j[1].__hash__() not in seen:
new_fringe[j[1].__hash__()] = (j[1], fringe[i][0], j[0], j[0][0])
seen[j[1].__hash__()] = (j[1], fringe[i][0], j[0], j[0][0])
fringe = new_fringe
def fillRubiks(self):
top = (self.size - 2)
id = 0
for x in range(self.size):
for y in range(self.size):
for z in range(self.size):
self.rubiks[x][y][z] = Cube.Cube(True, id)
self.rubiks[x][y][z].setCords(x, y, z)
if x <= top:
self.rubiks[x][y][z].removeSide(0)
if x >= 1:
self.rubiks[x][y][z].removeSide(1)
if y <= top:
self.rubiks[x][y][z].removeSide(2)
if y >= 1:
self.rubiks[x][y][z].removeSide(3)
if z <= top:
self.rubiks[x][y][z].removeSide(4)
if z >= 1:
self.rubiks[x][y][z].removeSide(5)
id += 1
def test():
# set up tests
cubeFactory = Cube()
sphereFactory = Sphere()
cylinderFactory = Cylinder()
cube = cubeFactory.build_triangle_mesh(256)
sphere = sphereFactory.build_triangle_mesh(256)
cylinder = cylinderFactory.build_triangle_mesh(256)
# do tests
print("#### CUBE ####")
cube.test_integrity()
print("\n")
print("#### CYLINDER ####")
cylinder.test_integrity()
print("\n")
print("#### SPHERE ####")
sphere.test_integrity()
print("\n")
