def trataCirculo(atual, Q, beach, CircDraw):
pred, suc, novo = beach.remove_circ(atual.leaf)
if pred is not None:
idc = control.plot_segment(pred.startp.x, pred.startp.y, novo.startp.x,
novo.startp.y)
edges.append((Ponto(pred.startp.x,
pred.startp.y), Ponto(novo.startp.x,
novo.startp.y)))
if suc is not None:
idc = control.plot_segment(suc.startp.x, suc.startp.y, novo.startp.x,
novo.startp.y)
edges.append((Ponto(suc.startp.x,
suc.startp.y), Ponto(novo.startp.x,
novo.startp.y)))
if novo is not None:
p, q = novo.value
drawDelaunayEdge(p.x, p.y, q.x, q.y)
evc, rem = beach.atualiza_eventos_circ(novo, atual.y, pred, suc)
for ev in rem:
CircDraw.rem_point(ev.x, ev.y)
Q.take(ev)
for ev in evc:
c = ev.event
if c.y <= atual.y:
CircDraw.add_point(c.x, c.y)
Q.put(c, c)
def draw(self, col='#ffff00'):
if (len(self.d_ids) > 0): return
v1, v2, v3 = self.v1, self.v2, self.v3
self.d_ids.append(
control.plot_segment(v1.x, v1.y, v2.x, v2.y, color=col))
self.d_ids.append(
control.plot_segment(v2.x, v2.y, v3.x, v3.y, color=col))
self.d_ids.append(
control.plot_segment(v1.x, v1.y, v3.x, v3.y, color=col))
def __caseThree(self, BST, v):
control.sleep()
firstTrap = BST.getTrapAndRemove(v)
x = firstTrap.topSuppVertex
if self.__interiorDownCusp(x):
xNumber = x.vertexNumber()
vNumber = v.vertexNumber()
diagonal = (xNumber, vNumber)
self.dcel.addHalfEdge(diagonal)
self.partitionDiagonalList.append([
(xNumber, vNumber),
control.plot_segment(x.x, x.y, v.x, v.y, "yellow")
])
if (firstTrap.leftEdge[1] != v) or (firstTrap.rightEdge[1] != v):
secondTrap = BST.getTrapAndRemove(v)
y = secondTrap.topSuppVertex
if self.__interiorDownCusp(y):
yNumber = y.vertexNumber()
vNumber = v.vertexNumber()
diagonal = (yNumber, vNumber)
self.dcel.addHalfEdge(diagonal)
self.partitionDiagonalList.append([
(yNumber, vNumber),
control.plot_segment(y.x, y.y, v.x, v.y, "yellow")
])
if firstTrap.rightEdge[1] == v:
newTrap = bst.Trap(firstTrap.leftEdge, v, secondTrap.rightEdge)
BST.insert(newTrap)
leftId = self.dcel.buildSegmentFromEdge(firstTrap.leftEdge).hilight(
color_line="blue", color_point="red")
rightId = self.dcel.buildSegmentFromEdge(secondTrap.rightEdge).hilight(
color_line="blue", color_point="red")
else:
newTrap = bst.Trap(secondTrap.leftEdge, v, firstTrap.rightEdge)
BST.insert(newTrap)
leftId = self.dcel.buildSegmentFromEdge(secondTrap.leftEdge).hilight(
color_line="blue", color_point="red")
rightId = self.dcel.buildSegmentFromEdge(firstTrap.rightEdge).hilight(
color_line="blue", color_point="red")
control.sleep()
control.plot_delete(leftId)
control.plot_delete(rightId)
def recursive_ham_sandwich(G1, G2, p1, p2, T):
if len(G1) < len(G2):
return recursive_ham_sandwich(G2, G1, p2, p1, T)
T, is_base = new_interval(G1, G2, p1, p2, T)
if is_base:
valid_answers = []
for g in G1:
for h in G2:
p = g.intersect(h)
if p and isinstance(p.dual(), Line):
valid_answers.append(p.dual())
return valid_answers, G1 + G2
t = new_trapezoid(G1, p1, T)
t_ids = []
control.freeze_update()
for i in range(4):
j = (i + 1) % 4
t_ids.append(
control.plot_segment(t[i].x, t[i].y, t[j].x, t[j].y, 'yellow'))
control.sleep()
control.thaw_update()
G1, p1 = discard_lines(G1, p1, t)
G2, p2 = discard_lines(G2, p2, t)
for id in t_ids:
control.plot_delete(id)
return recursive_ham_sandwich(G1, G2, p1, p2, T)
def needs_fix(self, other):
# inter are the edges self and other have in common
inter, dif = self.get_relative_vertices(other)
# check if quad is convex
if (len(inter) != 2 or len(dif) != 2):
print("ERRO NA LEGALIZACAO")
exit(1)
if self.v1 in inter:
if self.v2 in inter:
inter_0 = self.v1
inter_1 = self.v2
dif_0 = self.v3
else:
inter_0 = self.v3
inter_1 = self.v1
dif_0 = self.v2
else:
inter_0 = self.v2
inter_1 = self.v3
dif_0 = self.v1
if other.v1 in inter:
if other.v2 in inter:
dif_1 = other.v3
else:
dif_1 = other.v2
else:
dif_1 = other.v1
if not left(inter_0, inter_1, dif_1):
aux = dif_0
dif_0 = dif_1
dif_1 = aux
convex = left(inter_0, dif_0, inter_1) and\
left(dif_0, inter_1, dif_1) and\
left(inter_1, dif_1, inter_0) and\
left(dif_1, inter_0, dif_0)
if not convex: return False
# check if inter is best
# only draws if passes convex
self.draw("#ffaa33")
other.draw("#ffaa33")
did = control.plot_segment(inter_0.x, inter_0.y, inter_1.x,\
inter_1.y, color="#ffffff")
control.sleep()
control.plot_delete(did)
self.remove_draw()
other.remove_draw()
C = Circle(inter_0, inter_1, dif_0)
C.draw()
control.sleep()
C.remove_draw()
return C.is_inside(dif_1)
def __addDiagonal(self, currentVertex):
currentVertexNumberPolyDCEL = self.polyDCEL.mapCoordinateToNumber[(
currentVertex.x, currentVertex.y)]
stackTopVertexNumberPolyDCEL = self.polyDCEL.mapCoordinateToNumber[(
self.__stackTop().x, self.__stackTop().y)]
self.polyDCEL.addHalfEdge(
(currentVertexNumberPolyDCEL, stackTopVertexNumberPolyDCEL))
self.monotoneDiagonalList.append([
(currentVertexNumberPolyDCEL, stackTopVertexNumberPolyDCEL),
control.plot_segment(currentVertex.x, currentVertex.y, self.__stackTop(
).x, self.__stackTop().y, "white")
])
def __hilightSegment(self,
initPointIndex,
toPointIndex,
lineColor="yellow",
pointColor="yellow",
lineWidth=2):
initPoint = self.pointList[initPointIndex]
toPoint = self.pointList[toPointIndex]
lineId = control.plot_segment(initPoint.x, initPoint.y, toPoint.x,
toPoint.y, lineColor, lineWidth)
initPointId = initPoint.hilight(pointColor)
toPointId = toPoint.hilight(pointColor)
return [lineId, initPointId, toPointId]
def draw_partial_rec(self,c,node): if node.left is None or node.right is None: return p = node.value[0] q = node.value[1] x = self.parabolaIntersectX(p,q,c) id_list = [] if p.y != c: y = (p.x*p.x - 2*p.x*x + x*x + p.y*p.y - c*c)/(2*(p.y-c)) line_id = control.plot_segment(x,y,node.startp.x,node.startp.y) id_list = [line_id] id_list.append(self.draw_partial_rec(c,node.left)) id_list.append(self.draw_partial_rec(c,node.right)) return id_list
def __caseTwo(self, BST, u, v, w):
control.sleep()
if (left(u.coordinates, v.coordinates, w.coordinates)):
u, w = w, u
trap = BST.getTrapAndRemove(v)
if trap is None:
leftEdge = [v, u]
rightEdge = [v, w]
newTrap = bst.Trap(leftEdge, v, rightEdge)
BST.insert(newTrap)
else:
rightEdge = [v, u]
newTrap = bst.Trap(trap.leftEdge, v, rightEdge)
BST.insert(newTrap)
leftEdge = [v, w]
newTrap = bst.Trap(leftEdge, v, trap.rightEdge)
BST.insert(newTrap)
secLeftId = self.dcel.buildSegmentFromEdge(trap.leftEdge).hilight(
color_line="blue", color_point="red")
secRightId = self.dcel.buildSegmentFromEdge(trap.rightEdge).hilight(
color_line="blue", color_point="red")
x = trap.topSuppVertex
xNumber = x.vertexNumber()
vNumber = v.vertexNumber()
diagonal = (xNumber, vNumber)
self.dcel.addHalfEdge(diagonal)
self.partitionDiagonalList.append([
(xNumber, vNumber),
control.plot_segment(x.x, x.y, v.x, v.y, "yellow")
])
leftId = self.dcel.buildSegmentFromEdge(leftEdge).hilight(
color_line="blue", color_point="red")
rightId = self.dcel.buildSegmentFromEdge(rightEdge).hilight(
color_line="blue", color_point="red")
control.sleep()
control.plot_delete(leftId)
control.plot_delete(rightId)
if (trap is not None):
control.plot_delete(secLeftId)
control.plot_delete(secRightId)
def __caseOne(self, BST, u, v, w):
control.sleep()
if (u.y < w.y):
u, w = w, u
trap = BST.getTrapAndRemove(v)
x = trap.topSuppVertex
if v == trap.leftEdge[1]:
leftEdge = [v, w]
rightEdge = trap.rightEdge
newTrap = bst.Trap(leftEdge, v, rightEdge)
BST.insert(newTrap)
else:
leftEdge = trap.leftEdge
rightEdge = [v, w]
newTrap = bst.Trap(leftEdge, v, rightEdge)
BST.insert(newTrap)
leftId = self.dcel.buildSegmentFromEdge(leftEdge).hilight(
color_line="blue", color_point="red")
rightId = self.dcel.buildSegmentFromEdge(rightEdge).hilight(
color_line="blue", color_point="red")
if self.__interiorDownCusp(x):
xNumber = x.vertexNumber()
vNumber = v.vertexNumber()
diagonal = (xNumber, vNumber)
self.dcel.addHalfEdge(diagonal)
self.partitionDiagonalList.append([
(xNumber, vNumber),
control.plot_segment(x.x, x.y, v.x, v.y, "yellow")
])
control.sleep()
control.plot_delete(leftId)
control.plot_delete(rightId)
def fix_illegal(to_fix):
global DG, dcel
frontier = set() # set of edges that needs fixing
fixed = set() # set of fixed edges
for t in to_fix:
for e in t.get_edges():
if (e[1], e[0]) not in frontier:
frontier.add(e)
while (len(frontier) > 0):
did = None
e = frontier.pop()
he1 = dcel.get_hedge(e)
he2 = dcel.get_hedge((e[1], e[0])) # twin of e1
f1 = he1.face
f2 = he2.face
if he1.face is None or he2.face is None: #outer triangle
pass
elif he1.face.needs_fix(he2.face):
he1_nxt = he1.next
he2_nxt = he2.next
dcel.remove_edge(e[0], e[1])
# new triangles maintained counter-clockwise
n_t1 = Node(e[1], he1_nxt.destine, he2_nxt.destine)
n_t2 = Node(e[0], he2_nxt.destine, he1_nxt.destine)
# updates DAG
DG.add_node(n_t1)
DG.add_node(n_t2)
DG.add_edge(f1, n_t1)
DG.add_edge(f1, n_t2)
DG.add_edge(f2, n_t1)
DG.add_edge(f2, n_t2)
# updates DCEL
n_he1 = hedge(he1_nxt.destine, he2_nxt.destine, n_t1,\
he1_nxt, he1_nxt.prev)
n_he1.next.prev = n_he1
n_he1.prev.next = n_he1
n_he1.prev.face = n_t1
n_he1.next.face = n_t1
n_he2 = hedge(he2_nxt.destine, he1_nxt.destine, n_t2,\
he2_nxt, he2_nxt.prev)
n_he2.next.prev = n_he2
n_he2.prev.next = n_he2
n_he2.prev.face = n_t2
n_he2.next.face = n_t2
dcel.add_hedge(n_he1)
dcel.add_hedge(n_he2)
n_t1.draw()
n_t2.draw()
did = control.plot_segment(n_he1.origin.x, n_he1.origin.y,\
n_he1.destine.x, n_he1.destine.y, color="#ffffff")
control.sleep()
control.plot_delete(did)
n_t1.remove_draw()
n_t2.remove_draw()
# adds new illegal checks
for e in n_t1.get_edges():
if (e[1], e[0]) not in frontier:
frontier.add(e)
for e in n_t2.get_edges():
if (e[1], e[0]) not in frontier:
frontier.add(e)
if n_he1.face != n_he1.next.face or\
n_he1.face != n_he1.prev.face or\
n_he2.face != n_he2.next.face or\
n_he2.face != n_he2.prev.face:
print("BIG PROBLEM")
def drawDelaunayEdge(a, b, c, d):
if DelaunayTriangDraw == True:
control.plot_segment(a, b, c, d, color=config.COLOR_ALT3)
