def test_rightsibling():
"""rightsibling."""
dan = Node("Dan")
jet = Node("Jet", parent=dan)
jan = Node("Jan", parent=dan)
joe = Node("Joe", parent=dan)
eq_(rightsibling(dan), None)
eq_(rightsibling(jet), jan)
eq_(rightsibling(jan), joe)
eq_(rightsibling(joe), None)
def test_get_next_sibling():
template = XMLTemplateParser("""
<template name="root" sizing="auto">
<area name="child0" size="4"></area>
<area name="child1" size="4"></area>
<area name="child2" size="4"></area>
<area name="child3" size="4"></area>
<area name="child4" size="4"></area>
</template>
""").parse()
assert template.child3 == rightsibling(template.child2)
assert template.child1 == rightsibling(template.child0)
assert None == rightsibling(template.child4)
def get_max_size(self, template):
"""Returns a template's maximum possible size depending on the offset of
its successor or size of it's parent.
"""
from .properties import AutoSizeValueProperty, OffsetValueProperty
next_sibling = rightsibling(template)
if next_sibling and isinstance(next_sibling.offset_property,
OffsetValueProperty):
return next_sibling.offset - template.offset
elif (next_sibling and template.parent and not isinstance(
template.parent.size_property, AutoSizeValueProperty)):
siblings = rightsiblings(template)
return template.parent.size - self.get_size_of_siblings(
siblings) - template.offset
elif template.parent and not isinstance(template.parent.size_property,
AutoSizeValueProperty):
return template.parent.size - template.offset
elif template.parent and template.parent.boundary > 0:
return template.parent.boundary - template.offset
elif template.binding_context.data:
data = template.binding_context.data
data.seek(0, 2)
return data.tell()
else:
return 0
def getneighbour(self, left_right: str) -> ProofNode:
"""Zwraca prawego, lub lewego sąsiada danego węzła.
Równie dobrze można używać `anytree.util.rightsibling(self)` oraz `anytree.util.leftsibling(self)`
:param left_right: 'L/Left' lub 'R/Right'
:type left_right: str
:raises ProofNodeError: Podano niepoprawny kierunek
:return: Sąsiad
:rtype: ProofNode
"""
if not self.parent:
return None
if left_right.upper() in ('R', 'RIGHT'):
return util.rightsibling(self)
elif left_right.upper() in ('L', 'LEFT'):
return util.leftsibling(self)
else:
raise ProofNodeError(f"'{left_right}' is not a valid direction")
def doAlgorithm(size, obstaculos):
tablero, xInicio, yInicio = construirTablero(size, obstaculos)
expansionMaxima = ((len(tablero) * len(tablero)) - obstaculos) * 2
print(f'Numero de estados => {expansionMaxima}')
if tablero[xInicio][yInicio] != 0:
messagebox.showerror(
message=
"Por azares del destino, el tablero no cuenta con una casilla de salida, que mala suerte...",
title="Upss")
raise Exception(
"Por azares del destino, el tablero no cuenta con una casilla de salida, que mala suerte..."
)
nodoRaiz = Node(tablero[xInicio][yInicio], id=uniqueID())
nodoCursor = None
nodosVisitados = []
mostrarTablero(tablero)
valorArriba = arriba(tablero, xInicio, yInicio)
if (valorArriba != None):
uid = uniqueID()
nodoCursor = Node(valorArriba, parent=nodoRaiz, id=uid)
valorDerecha = derecha(tablero, xInicio, yInicio)
if (valorDerecha != None):
uid = uniqueID()
nodoCursor = Node(valorDerecha, parent=nodoRaiz, id=uid)
valorAbajo = abajo(tablero, xInicio, yInicio)
if (valorAbajo != None):
uid = uniqueID()
nodoCursor = Node(valorAbajo, parent=nodoRaiz, id=uid)
valorIzquierda = izquierda(tablero, xInicio, yInicio)
if (valorIzquierda != None):
uid = uniqueID()
nodoCursor = Node(valorIzquierda, parent=nodoRaiz, id=uid)
nodosVisitados.append(nodoRaiz.name)
nodoHijoEvaluando = nodoRaiz.children[0]
# while nodoHijoEvaluando != None:
# yaPasePorAqui = existeEnLaPila(nodosVisitados, nodoHijoEvaluando.name)
# if yaPasePorAqui == False:
# nodosVisitados.append(nodoHijoEvaluando.name)
# if nodoHijoEvaluando.name == -100: # Solucion
# break
# coordenadasHijoEvaluando = getCoords(tablero, nodoHijoEvaluando.name)
# _x = int(coordenadasHijoEvaluando[0])
# _y = int(coordenadasHijoEvaluando[1])
# valorArriba = arriba(tablero, _x, _y)
# if(valorArriba != None):
# uid = uniqueID()
# hijo = Node(valorArriba, parent=nodoHijoEvaluando, id=uid)
# valorDerecha = derecha(tablero, _x, _y)
# if(valorDerecha != None):
# uid = uniqueID()
# hijo = Node(valorDerecha, parent=nodoHijoEvaluando, id=uid)
# valorAbajo = abajo(tablero, _x, _y)
# if(valorAbajo != None):
# uid = uniqueID()
# hijo = Node(valorAbajo, parent=nodoHijoEvaluando, id=uid)
# valorIzquierda = izquierda(tablero, _x, _y)
# if(valorIzquierda != None):
# uid = uniqueID()
# hijo = Node(valorIzquierda, parent=nodoHijoEvaluando, id=uid)
# nodoHijoEvaluando = nodoHijoEvaluando.children[0]
# else:
# try:
# nodoHijoEvaluando = rightsibling(nodoHijoEvaluando)
# except Exception:
# nodoHijoEvaluando = rightsibling(nodoHijoEvaluando.parent)
nodoSalida = None
# Implementación con un nivel de profundidad máximo
while nodoHijoEvaluando != None: # Iteramos a lo bestia :v
# yaPasePorAqui = existeEnLaPila(nodosVisitados, nodoHijoEvaluando.name)
profundidad = nodoHijoEvaluando.depth
if nodoHijoEvaluando.name == -100:
print("Acabo de encontrar la salida :D")
nodoSalida = nodoHijoEvaluando
break
elif profundidad > expansionMaxima:
# Pasar al siguiente nodo segun profundidad maxmma
try:
nodoHijoEvaluando = rightsibling(nodoHijoEvaluando)
except Exception:
nodoHijoEvaluando = rightsibling(nodoHijoEvaluando.parent)
else:
coordenadasHijoEvaluando = getCoords(tablero,
nodoHijoEvaluando.name)
_x = int(coordenadasHijoEvaluando[0])
_y = int(coordenadasHijoEvaluando[1])
valorArriba = arriba(tablero, _x, _y)
if (valorArriba != None):
uid = uniqueID()
hijo = Node(valorArriba, parent=nodoHijoEvaluando, id=uid)
valorDerecha = derecha(tablero, _x, _y)
if (valorDerecha != None):
uid = uniqueID()
hijo = Node(valorDerecha, parent=nodoHijoEvaluando, id=uid)
valorAbajo = abajo(tablero, _x, _y)
if (valorAbajo != None):
uid = uniqueID()
hijo = Node(valorAbajo, parent=nodoHijoEvaluando, id=uid)
valorIzquierda = izquierda(tablero, _x, _y)
if (valorIzquierda != None):
uid = uniqueID()
hijo = Node(valorIzquierda, parent=nodoHijoEvaluando, id=uid)
nodoHijoEvaluando = nodoHijoEvaluando.children[0]
# else:
# try:
# nodoHijoEvaluando = rightsibling(nodoHijoEvaluando)
# except Exception:
# nodoHijoEvaluando = rightsibling(nodoHijoEvaluando.parent)
return nodoRaiz, nodoSalida
def is_left_argument(child_node):
return(rightsibling(child_node) != None)
def iniciar_algoritmo_principal(tablero):
# Indicar los obstáculos, salida e inicio
expansionMaxima = (
(len(tablero) * len(tablero)) - len(array_obstaculos)) * 2
print(f'Numero de estados: {expansionMaxima}')
array_tmp = obtener_coordenadas(tablero, 0)
xInicio = int(array_tmp[0])
yInicio = int(array_tmp[1])
nodoRaiz = Node(tablero[xInicio][yInicio], id=obtener_ID_unico())
banderaSalidaEncontrada = False
valorir_arriba = ir_arriba(tablero, xInicio, yInicio)
if (valorir_arriba != None):
uid = obtener_ID_unico()
Node(valorir_arriba, parent=nodoRaiz, id=uid)
valorir_derecha = ir_derecha(tablero, xInicio, yInicio)
if (valorir_derecha != None):
uid = obtener_ID_unico()
Node(valorir_derecha, parent=nodoRaiz, id=uid)
valorir_abajo = ir_abajo(tablero, xInicio, yInicio)
if (valorir_abajo != None):
uid = obtener_ID_unico()
Node(valorir_abajo, parent=nodoRaiz, id=uid)
valorir_izquierda = ir_izquierda(tablero, xInicio, yInicio)
if (valorir_izquierda != None):
uid = obtener_ID_unico()
Node(valorir_izquierda, parent=nodoRaiz, id=uid)
nodoHijoEvaluando = nodoRaiz.children[0]
# Implementación con un nivel de profundidad máximo
while banderaSalidaEncontrada == False: # Iteramos a lo bestia :v
profundidad = nodoHijoEvaluando.depth
if nodoHijoEvaluando.name == -100:
print("Acabo de encontrar la salida :D => ", nodoHijoEvaluando)
# nodoHijoEvaluando = None
banderaSalidaEncontrada = True
elif profundidad > (expansionMaxima - 1):
# Pasar al siguiente nodo segun profundidad maxima
_nodo = rightsibling(nodoHijoEvaluando)
if (_nodo != None):
nodoHijoEvaluando = _nodo
else:
while (_nodo == None):
nodoHijoEvaluando = nodoHijoEvaluando.parent
_nodo = rightsibling(nodoHijoEvaluando)
nodoHijoEvaluando = _nodo
else:
coordenadasHijoEvaluando = obtener_coordenadas(
tablero, nodoHijoEvaluando.name)
_x = int(coordenadasHijoEvaluando[0])
_y = int(coordenadasHijoEvaluando[1])
valorir_arriba = ir_arriba(tablero, _x, _y)
if (valorir_arriba != None):
uid = obtener_ID_unico()
Node(valorir_arriba, parent=nodoHijoEvaluando, id=uid)
valorir_derecha = ir_derecha(tablero, _x, _y)
if (valorir_derecha != None):
uid = obtener_ID_unico()
Node(valorir_derecha, parent=nodoHijoEvaluando, id=uid)
valorir_abajo = ir_abajo(tablero, _x, _y)
if (valorir_abajo != None):
uid = obtener_ID_unico()
Node(valorir_abajo, parent=nodoHijoEvaluando, id=uid)
valorir_izquierda = ir_izquierda(tablero, _x, _y)
if (valorir_izquierda != None):
uid = obtener_ID_unico()
Node(valorir_izquierda, parent=nodoHijoEvaluando, id=uid)
nodoHijoEvaluando = nodoHijoEvaluando.children[0]
return nodoRaiz
