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 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 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 main():
r = float(input("What is the radius: "))
sphere = GeoSphere(r)
print("The volume is {0:0.0f} m3 and the area is {1:0.0f} m2.".format(sphere.volume(),sphere.surfaceArea()))
l = float(input("What is the length of a side?"))
cube = Cube(l)
print("The volume is {0:0.0f} m3 and the area is {1:0.0f} m2.".format(cube.volumeCube(),cube.surfaceArea()))
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 display(self):
y = 0
for row in self.number:
x = 0
for cube in row:
if cube:
theCube = Cube(0.35, self.color)
glPushMatrix()
glTranslated(2.55, 10.5, 0)
glTranslated(-x * 1.1 * theCube.size, -y * 1.1 * theCube.size, 16)
theCube.display()
glPopMatrix()
x += 1
y += 1
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 myprior(cube, ndim, nparams):
""" MultiNest callback function. Sets the model parameters
from the unit hypercube.
Arguments:
cube -- Unit hypercube from which model parameters are mapped.
ndim -- Number of model paramers.
nparams -- Total number of parameters in the cube .
Returns:
"""
# Set-up the paramters - CMSSM model.
Model = CMSSMModelTracker()
# Set the model parameters from the cube.
Model.SetParams(cube)
# Copy them to the cube so that they are printed, in alphabetical order.
for name in sorted(Model.param.keys(), key=str.lower):
Cube.AddCube(cube, Model.param[name].value, Cube.label, name)
# Print-out cube model parameters for debugging.
print '*****************************************************'
print 'Parameters:'
for i in range(Cube.AddCube.count() + 1): # Count begins at 0 - need +1.
print Cube.label[i], cube[i]
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 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 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
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 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 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():
c = Cube()
randomize(c, 3)
print c
solver = EntropicSolver(c, BasicEntropyEstimator())
solver.solve()
print c
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 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
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 __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 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 checkValidityOfLinks(self, cubeNetFile):
"""
Checks the validity of each of the transit links against the given cubeNetFile.
That is, each link in a .lin should either be in the roadway network, or in a .link file.
"""
import Cube
(nodes_dict, links_dict) = Cube.import_cube_nodes_links_from_csvs(cubeNetFile,
extra_link_vars=['LANE_AM', 'LANE_OP','LANE_PM',
'BUSLANE_AM', 'BUSLANE_OP', 'BUSLANE_PM'],
extra_node_vars=[],
links_csv=os.path.join(os.getcwd(),"cubenet_validate_links.csv"),
nodes_csv=os.path.join(os.getcwd(),"cubenet_validate_nodes.csv"),
exportIfExists=True)
for line in self:
# todo fix this
line_is_oneway = True
last_node = None
for node in line:
# this is the first node - nothing to do
if not last_node:
last_node = node
continue
# we need to check this link but possibly also the reverse
link_list = [(abs(last_node), abs(node))]
if not line_is_oneway:
link_list.append((abs(node), abs(last_node)))
# check the link(s)
for (a,b) in link_list:
# it's a road link
if (a,b) in links_dict: continue
found_link = False
for link in self.links:
if not isinstance(link,TransitLink): continue
if link.Anode == a and link.Bnode == b:
found_link = True
break
if not link.isOneway() and link.Anode == b and link.Bnode == a:
found_link = True
break
if found_link: continue
WranglerLogger.debug("TransitNetwork.checkValidityOfLinks: (%d, %d) not in the roadway network nor in the off-road links (line %s)" % (a, b, line.name))
last_node = node
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 __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 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 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")
def IDA_star_Test(n, scramble_length, tests, outputs, output_name, time_out, heuristic):
print('Testing IDA*: n=' + str(n) + ', scramble_length: ' + str(scramble_length) + ', tests: ' + str(tests))
results = [['Trial', 'scrambleLength', 'scramblePattern', 'scrambleHash', 'obviousSolution', 'correct', 'solvedTime(sec)', 'aiPath']]
for i in range(tests):
c = Cube(n)
scramble_pattern = c.trueScramble(scramble_length)
scramble_hash = c.__hash__()
obvious_solution = Cube.obviousSolution(scramble_pattern)
ai = IDA_Star(c, heuristic)
start_time = time.time()
try:
ai_path = ai.solve(time_out)
print(ai_path)
# Run didn't time out!
run_time = time.time() - start_time
correct = ai_path[-1][1].isSolved()
better_ai_path = []
for j in ai_path:
better_ai_path.append((j[0], j[1].state, j[1].__hash__()))
except Exception as e:
run_time = 'timed out (>' + str(time_out) + ' secs)'
better_ai_path = []
correct = False
print('Timed out')
print('\tTrial ' + str(i+1) + ': scramble_length: ' + str(scramble_length) + '; scramble_pattern: ' + str(scramble_pattern) + '; correct: ' + str(correct) + '; solved time: ' + str(run_time) + ' sec; ai_length: ' + str(len(better_ai_path)) + '; ai_path: ' + str(better_ai_path))
results.append([i+1, scramble_length, scramble_pattern, scramble_hash, obvious_solution, correct, run_time, better_ai_path])
if 'csv' in outputs:
file = open(output_name+'.csv', 'w', newline='')
with file:
writer = csv.writer(file)
writer.writerows(results)
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()
# main.py
from pygame import *
from random import *
from Object import *
from Cube import *
import os
os.environ['SDL_VIDEO_WINDOW_POS'] = '100,50'
screen = display.set_mode((1000, 900))
display.set_caption("3D")
clock = time.Clock()
cube = Cube(500, 50, 2000, 50)
running = True
while running:
screen.fill((0, 0, 0))
for e in event.get():
if e.type == QUIT:
running = False
pressed = key.get_pressed()
cube.updateVar(pressed)
cube.render(screen)
display.flip()
quit()
class TestCubeSimple(unittest.TestCase):
"""Test de Cube() -- part 1"""
def setUp(self):
self.cube = Cube() # un cube résolu
def tearDown(self):
self.cube = None
def testCubes(self):
"""Un Cube() doit posséder tous les petits cubes"""
keysExpected = [
# 1ère couronne
"FU",
"FRU",
"RU",
"RBU",
"BU",
"BLU",
"LU",
"LFU",
# 2ème couronne
"FR",
"BR",
"BL",
"FL",
# 3ème couronne
"FD",
"FRD",
"RD",
"RBD",
"BD",
"BLD",
"LD",
"LFD",
]
self.assertListEqual(sorted(keysExpected), sorted(list(self.cube.cubes.keys())))
def testCubesValues(self):
"""Un cube doit être résolu par défault"""
cubes = [
# 1ère couronne
("FU", [1, 5]),
("FRU", [1, 2, 5]),
("RU", [2, 5]),
("RBU", [2, 3, 5]),
("BU", [3, 5]),
("BLU", [3, 4, 5]),
("LU", [4, 5]),
("LFU", [4, 1, 5]),
# 2ème couronne
("FR", [1, 2]),
("BR", [3, 2]),
("BL", [3, 4]),
("FL", [1, 4]),
# 3ème couronne
("FD", [1, 0]),
("FRD", [1, 2, 0]),
("RD", [2, 0]),
("RBD", [2, 3, 0]),
("BD", [3, 0]),
("BLD", [3, 4, 0]),
("LD", [4, 0]),
("LFD", [4, 1, 0]),
]
for cube, facettes in cubes:
self.assertTrue(numpy.array_equal(self.cube.cubes[cube], facettes))
def testGetFacettes(self):
"""Cube.get_facettes() doit retourner la bonne facette"""
cubes = [
# 1ère couronne
("FU", Array([1, 5])),
("FRU", Array([1, 2, 5])),
("RU", Array([2, 5])),
("RBU", Array([2, 3, 5])),
("BU", Array([3, 5])),
("BLU", Array([3, 4, 5])),
("LU", Array([4, 5])),
("LFU", Array([4, 1, 5])),
# 2ème couronne
("FR", Array([1, 2])),
("BR", Array([3, 2])),
("BL", Array([3, 4])),
("FL", Array([1, 4])),
# 3ème couronne
("FD", Array([1, 0])),
("FRD", Array([1, 2, 0])),
("RD", Array([2, 0])),
("RBD", Array([2, 3, 0])),
("BD", Array([3, 0])),
("BLD", Array([3, 4, 0])),
("LD", Array([4, 0])),
("LFD", Array([4, 1, 0])),
]
for cube, facettes in cubes:
for index, facette in enumerate(facettes):
self.assertEqual(self.cube.get_facette(cube, index), facette)
def testEditCubeException(self):
"""Cube.edit_cube() doit accepter uniquement des cubes"""
with self.assertRaises(ValueError):
self.cube.edit_cube("abc", [0, 1])
with self.assertRaises(ValueError):
self.cube.edit_cube(0, [0, 1])
with self.assertRaises(ValueError):
self.cube.edit_cube(None, [0, 1])
def testEditCubeGroup(self):
"""
Cube.edit_cube() doit s'assurer qu'un même groupe de couleurs
n'est pas présent plus d'une fois
"""
with self.assertRaises(ValueError):
self.cube.edit_cube("FRU", [0, 1, 0])
with self.assertRaises(ValueError):
self.cube.edit_cube("FRU", [2, 2, 2])
with self.assertRaises(ValueError):
self.cube.edit_cube("FRU", [0, 5, 5])
def testEditCubeGroup(self):
"""Cube.edit_cube() doit planter si problème de taille de cube"""
with self.assertRaises(ValueError):
self.cube.edit_cube("FRU", [0, 1])
with self.assertRaises(ValueError):
self.cube.edit_cube("FU", [0, 1, 2])
def testEditCubeCouleur(self):
"""Cube.edit_cube() ne doit accèpter que des couleurs"""
with self.assertRaises(ValueError):
self.cube.edit_cube("FRU", [0, 1, 8])
def testEditCubeEdit(self):
"""Cube.edit_cube() doit faire son job"""
self.cube.edit_cube("FRU", [0, 1, 2])
self.assertTrue(numpy.array_equal(self.cube.cubes["FRU"], [0, 1, 2]))
def testCubeContientCouleur(self):
"""Cube.cube_contient_couleur() doit faire son job"""
self.assertTrue(self.cube.cube_contient_couleur("FRU", 1, 2, 5))
self.assertFalse(self.cube.cube_contient_couleur("FRU", 0, 2, 5))
self.assertTrue(self.cube.cube_contient_couleur("FR", 1, 2))
self.assertFalse(self.cube.cube_contient_couleur("FR", 19, 2))
def testFaceResolueError(self):
"""Cube.face_resolue() ne doit accèpter que des faces"""
with self.assertRaises(ValueError):
self.cube.face_resolue("W")
def testFaceResolue(self):
"""
Cube.face_resolue() doit fonctionner sur toutes les faces d'un cube résolu
"""
for f in ["U", "L", "F", "R", "B", "D"]:
self.assertTrue(self.cube.face_resolue(f))
def testCubeResolu(self):
"""Cube.resolu() doit faire son job"""
c = Cube()
self.assertTrue(c.resolu())
c.rot_R()
self.assertFalse(c.resolu())
def testCubeResolu(self):
"""Cube.resolu() doit faire son job"""
c = Cube()
self.assertTrue(c.resolu())
c.rot_R()
self.assertFalse(c.resolu())
def validateTurnPens(self, CubeNetFile, turnPenReportFile=None, suggestCorrectLink=True):
import Cube
turnpens_files = ['turnsam.pen','turnsop.pen','turnspm.pen']
pen_regex = r'^\s*(?P<frnode>\d+)\s+(?P<thnode>\d+)\s+(?P<tonode>\d+)\s+\d+\s+(?P<pen>-[\d+])'
if turnPenReportFile:
outfile = open(turnPenReportFile,'w')
outfile.write('file,old_from,old_through,old_to,on_street,at_street,new_from,new_through,new_to,note\n')
(nodes_dict, links_dict) = Cube.import_cube_nodes_links_from_csvs(CubeNetFile,
extra_link_vars=['LANE_AM', 'LANE_OP','LANE_PM',
'BUSLANE_AM', 'BUSLANE_OP', 'BUSLANE_PM'],
extra_node_vars=[],
links_csv=os.path.join(os.getcwd(),"cubenet_validate_links.csv"),
nodes_csv=os.path.join(os.getcwd(),"cubenet_validate_nodes.csv"),
exportIfExists=True)
found_matches = {}
for file_name in turnpens_files:
f = open(file_name,'r')
for line in f:
text = line.split(';')[0]
m = re.match(pen_regex, text)
if m:
new_fr = None
new_th = None
new_to = None
from_street = 'missing'
to_street = 'missing'
fr_node = int(m.groupdict()['frnode'])
th_node = int(m.groupdict()['thnode'])
to_node = int(m.groupdict()['tonode'])
pen = int(m.groupdict()['pen'])
if not (fr_node,th_node) in links_dict:
WranglerLogger.debug("HighwayNetwork.validateTurnPens: (%d, %d) not in the roadway network for %s (%d, %d, %d)" % (fr_node,th_node,file_name,fr_node,th_node,to_node))
if suggestCorrectLink:
new_fr = -1
new_th = th_node
match_links_fr = []
match_links_th = []
# if we already found a match for this, don't keep looking.
if (fr_node,th_node) in found_matches.keys():
match = found_matches[(fr_node,th_node)]
new_fr = match[0][1]
else:
#catch the links matching fr_node on the from end
for (a,b) in links_dict.keys():
if a == fr_node:
match_links_fr.append((a,b))
# and links matching th_node on the to end
if b == th_node:
match_links_th.append((a,b))
# now take matched links and look for match_links_fr node b to match match_links_th node a
for (a1,b1) in match_links_fr:
for (a2,b2) in match_links_th:
if b1 == a2:
#WranglerLogger.info("For link1 (%d, %d) and link2 (%d, %d): %d == %d" % (a1,b1,a2,b2,b1,a2))
found_matches[(fr_node,th_node)] = [(a1,b1),(a2,b2)]
new_fr = a2
# index 1 is streetname
from_street = links_dict[(a2,b2)][1]
break
else:
new_fr = fr_node
from_street = links_dict[(fr_node,th_node)][1]
if not (th_node,to_node) in links_dict:
WranglerLogger.debug("HighwayNetwork.validateTurnPens: (%d, %d) not in the roadway network for %s (%d, %d, %d)" % (th_node,to_node,file_name,fr_node,th_node,to_node))
#if turnPenReportFile: outfile.write("%s,%d,%d,outbound link missing from, %d, %d, %d\n" %(file_name,th_node,to_node,fr_node,th_node,to_node))
if suggestCorrectLink:
new_th = th_node
new_to = -1
match_links_th = []
match_links_to = []
# if we already found a match for this, don't keep looking.
if (th_node,to_node) in found_matches.keys():
match = found_matches[(th_node,to_node)]
new_to = match[0][1]
else:
#catch the links matching fr_node on the from end
for (a,b) in links_dict.keys():
if a == th_node:
match_links_th.append((a,b))
# and links matching th_node on the to end
if b == to_node:
match_links_to.append((a,b))
# now take matched links and look for match_links_fr node b to match match_links_th node a
for (a1,b1) in match_links_th:
for (a2,b2) in match_links_to:
if b1 == a2:
#WranglerLogger.info("For link1 (%d, %d) and link2 (%d, %d): %d == %d" % (a1,b1,a2,b2,b1,a2))
found_matches[(th_node,to_node)] = [(a1,b1),(a2,b2)]
new_to = a2
to_street = links_dict[(a2,b2)][1]
break
else:
new_to = to_node
to_street = links_dict[(th_node,to_node)][1]
if new_th != None:
#outfile.write('file,old_from,old_through,old_to,on_street,at_street,new_from,new_through,new_to,note\n')
print file_name,fr_node,th_node,to_node,from_street,to_street,new_fr,new_th,new_to
outfile.write('%s,%d,%d,%d,%s,%s,%d,%d,%d,note\n' % (file_name,fr_node,th_node,to_node,from_street,to_street,new_fr if new_fr else -1,new_th,new_to if new_to else -1))
def setUp(self):
self.cube = Cube() # un cube résolu
