def BresenhamCircle(xc,yc,r):#xcentro, ycentro, radio
#iniciamos en 0,r
x = 0 + xc
y = r + yc
#p = 1 - r
p = 2*(x + 1)*(x + 1) + y*y + (y-1)*(y-1) - 2*r*r
p_new = [[xc,yc],[x,y]]
libreria1.DrawPixel(libreria1.Transform(p_new[0]), VERDE)
libreria1.DrawPixel(libreria1.Transform(p_new[1]), VERDE)
#se cicla hasta trazar todo un octante
while (x < y) :
x = x + 1 #siempre incrementamos en unidades enteras a x
if (p < 0) : #pintamos xi+1,yi
p = p + 4*x + 10 #segun mi ecuacion
#p = p + 4*x*x + 12*x + 4*y + 10
else : #pintamos xi+1,yi-1
y = y - 1
p = p + 4*(x - y) + 10
#p = p + y*y + 4*x - 5*y + 8
libreria1.DrawPixel(libreria1.Transform([x + xc,y + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([-x + xc,y + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([x + xc,-y + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([-x + xc,-y + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([y + xc,x + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([-y + xc,x + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([y + xc,-x + yc]), VERDE)
libreria1.DrawPixel(libreria1.Transform([-y + xc,-x + yc]), VERDE)
def Bresenham(recta, obj):
if (recta.getPoints()[0][0] > recta.getPoints()[1][0]): # Ax > Bx
[A, B] = libreria1.swap(recta.getPoints()[0], recta.getPoints()[1])
recta.setPoints(A, B)
parada = recta.getPoints()[1]
x_new = recta.getPoints()[0][0] #inicializamos
y_new = recta.getPoints()[0][1]
p_new = libreria1.Transform([x_new, y_new])
d_y = recta.getPoints()[1][1] - recta.getPoints()[0][1] #y2-y1
d_x = recta.getPoints()[1][0] - recta.getPoints()[0][0] #x2-x1
c = 2 * d_y + 2 * d_x * recta.getb() - d_x
if (recta.getPendiente() >= 0 and
recta.getPendiente() <= 1): # pendiente tiende a ser horizontal
while (x_new <= parada[0]): #xk <= xfinal
pk = 2 * d_y * x_new - 2 * d_x * y_new + c #criterio de decision
if (pk > 0): #d1 > d2
# hay que pintar (xk+1,yk)
y_new += 1 #innecesario de poner
#else : #d1 < d2
# hay que pintar (xk+1,yk+1)
x_new += 1
p_new = libreria1.Transform([x_new, y_new])
pantalla.fill(BLANCO)
pantalla.blit(obj, p_new)
reloj.tick(60)
pygame.display.flip()
def DDA_Y(recta, case):
print "DDA_Y"
print "A1: " , recta.getPoints()[0]
print "B1: " , recta.getPoints()[1]
# case 0 : # Yk+1 = Yk + m
# case 1 : # Yk+1 = Yk - m
print "CASO:" , case
i = 0
if(case == 0):#ya no vamos de A hacia B, si no al contrario
#print "A: " , recta.getPoints()[0] , "B: " , recta.getPoints()[1]
[A,B] = swap(recta.getPoints()[0],recta.getPoints()[1])
recta.setPoints(A,B)
print "A: " , A , "B: " , B
parada = recta.getPoints()[1]
print "punto de llegada: " , parada
while(True):
pivote = recta.getPoints()[0] # recta.[x1,y1]
#libreria1.DrawPixel(pivote, AZUL) #NO QUIERE SERVIR
libreria1.makeCircle(libreria1.Transform(pivote),1,VERDE)
print "pivote: " , pivote
new_y = int(round(pivote[1] + recta.getPendiente()))
new_x = int(round(( int(new_y) - recta.getb() ) / recta.getPendiente()))
new_point = [new_x,new_y]
#libreria1.DrawPixel(new_point, AZUL)
print "New point: " , new_point
libreria1.makeCircle(libreria1.Transform(new_point),1,VERDE)
if(new_y <= parada[1] ):#or i == 10): #Yk+1 <= Yk
return #parada
print "parada: " , parada
print "new_y: " , new_y
recta.setPoints([new_x,new_y],recta.getPoints()[1]) #recta = new_rect
i+=1
def Bresenham(recta):
if (recta.getPoints()[0][0] > recta.getPoints()[1][0]): # Ax > Bx
print "Ax : ", recta.getPoints()[0][0]
print "Bx : ", recta.getPoints()[1][0]
[A, B] = libreria1.swap(recta.getPoints()[0], recta.getPoints()[1])
print "new A : ", A
print "new B : ", B
recta.setPoints(A, B)
parada = recta.getPoints()[1]
x_new = recta.getPoints()[0][0] #inicializamos
y_new = recta.getPoints()[0][1]
p_new = libreria1.Transform([x_new, y_new])
libreria1.DrawPixel(p_new, VERDE)
d_y = recta.getPoints()[1][1] - recta.getPoints()[0][1] #y2-y1
d_x = recta.getPoints()[1][0] - recta.getPoints()[0][0] #x2-x1
c = 2 * d_y + 2 * d_x * recta.getb() - d_x
if (recta.getPendiente() >= 0 and
recta.getPendiente() <= 1): # pendiente tiende a ser horizontal
while (x_new <= parada[0]): #xk <= xfinal
pk = 2 * d_y * x_new - 2 * d_x * y_new + c #criterio de decision
if (pk > 0): #d1 > d2
# hay que pintar (xk+1,yk)
y_new += 1 #innecesario de poner
#else : #d1 < d2
# hay que pintar (xk+1,yk+1)
x_new += 1
p_new = libreria1.Transform([x_new, y_new])
libreria1.DrawPixel(p_new, VERDE)
if (recta.getPendiente() >
1): # pendiente tiende a ser mas vertical que horizontal
#ARREGLAR
c = 2 * d_x + 2 * d_y * recta.getb() - d_y
while (y_new <= parada[1]): #yk <= yfinal
pk = 2 * d_x * x_new - 2 * d_y * y_new + c #criterio de decision
if (pk < 0):
# hay que pintar (xk+1,yk+1)
x_new += 1 #innecesario de poner
#else :
# hay que pintar (xk,yk+1)
y_new += 1
p_new = libreria1.Transform([x_new, y_new])
libreria1.DrawPixel(p_new, VERDE)
if (recta.getPendiente() <= 0): #pendientes negativas
print "pendiente negativa"
pass
def Bresenham(x0, y0, x1, y1):
dx = (x1 - x0)
dy = (y1 - y0)
#determinar que punto usar para empezar, cual para terminar
if (dy < 0):
dy = -1 * dy
stepy = -1
else:
stepy = 1
if (dx < 0):
dx = -1 * dx
stepx = -1
else:
stepx = 1
x = x0
y = y0
p_new = [[x0, y0], [x0, y0]]
p1 = libreria1.Transform(p_new[0])
p2 = libreria1.Transform(p_new[1])
p_new = [p1, p2]
libreria1.DrawPixel(p1, VERDE)
libreria1.DrawPixel(p2, VERDE)
#se cicla hasta llegar al extremo de la linea
if (dx > dy):
p = 2 * dy - dx
incE = 2 * dy
incNE = 2 * (dy - dx)
while (x != x1):
x = x + stepx
if (p < 0):
p = p + incE
else:
y = y + stepy
p = p + incNE
p_new = [x, y]
p1 = libreria1.Transform(p_new)
libreria1.DrawPixel(p1, VERDE)
else:
p = 2 * dx - dy
incE = 2 * dx
incNE = 2 * (dx - dy)
while (y != y1):
y = y + stepy
if (p < 0):
p = p + incE
else:
x = x + stepx
p = p + incNE
p_new = [x, y]
p1 = libreria1.Transform(p_new)
libreria1.DrawPixel(p1, VERDE)
def DDA_X(recta, case):
print "DDA_X"
print "A1: " , recta.getPoints()[0]
print "B1: " , recta.getPoints()[1]
# case 0 : Xk+1 = Xk + 1/m
# case 1 : Xk+1 = Xk + 1/(-m)
print "CASO:" , case
i = 0
if(case == 1):#ya no vamos de A hacia B, si no al contrario
[A,B] = swap(recta.getPoints()[0],recta.getPoints()[1])
recta.setPoints(A,B)
print "A: " , A , "B: " , B
parada = recta.getPoints()[1]
print "punto de llegada: " , parada
while(True):
pivote = recta.getPoints()[0] # recta.[x1,y1]
print "pivote: " , pivote
#libreria1.DrawPixel(pivote, AZUL)
libreria1.makeCircle(libreria1.Transform(pivote),1,VERDE)
d_x = float(parada[0] - recta.getPoints()[0][0]) #x2-x1
print "d_x : " , d_x
m = 1/d_x #En esta se calcula con la pendiente nueva, no con la original
b = pivote[1] - d_x*pivote[0] #el b tambien se vuelve a calcular
new_x = int(round( pivote[0] + 1/m))
#new_x = pivote[0] + d_x
print "pivote[0] : " , pivote[0]
print "m : " , m
print "suma : " , pivote[0] + m
print "round : " , round( pivote[0] + 1/m )
new_y = int(round(d_x*(pivote[0] + m) + b))
new_point = [new_x,new_y]
print "New point: " , new_point
libreria1.makeCircle(libreria1.Transform(new_point),1,VERDE)
#ibreria1.DrawPixel(new_point, AZUL)
print "new_x: " , new_x
print "parada[0]: " , parada[0]
print "-----------------------"
if(new_x >= parada[0] ):#or i == 10): #Xk+1 >= Xk
return #parada
print "parada: " , parada
print "new_y: " , new_y
recta.setPoints([new_x,new_y],recta.getPoints()[1]) #actualiza
i+=1
def DDA(recta):
m = recta.getPendiente()
print "m : ", m
if (recta.getPoints()[0][1] > recta.getPoints()[1][1]
or recta.getPoints()[0][0] >
recta.getPoints()[1][0]): #Ay > By or Ax > Bx
[A, B] = libreria1.swap(recta.getPoints()[0], recta.getPoints()[1])
recta.setPoints(A, B)
parada = recta.getPoints()[1]
x_new = recta.getPoints()[0][0] #inicializamos
y_new = recta.getPoints()[0][1]
p_new = libreria1.Transform([x_new, y_new])
libreria1.DrawPixel(p_new, VERDE)
if (m <= 1): #incrementa en X
'''if(recta.getPoints()[0][0] > recta.getPoints()[1][0]):
m *= -1'''
while (x_new <= parada[0]):
libreria1.DrawPixel(p_new, VERDE)
print "plotted : ", libreria1.AntiTransform(p_new)
x_new += 1
y_new = y_new + m
y_plotted = int(round(y_new + m))
p_new = libreria1.Transform([x_new, y_plotted])
if (m > 1): #incrementa en Y
'''if(recta.getPoints()[0][1] > recta.getPoints()[1][1]):
m *= -1'''
while (y_new <= parada[1]):
x_new = x_new + 1 / m
x_plot = int(round(x_new + float(1 / m)))
y_new += 1
print x_new, y_new
p_new = libreria1.Transform([x_plot, y_new])
libreria1.DrawPixel(p_new, VERDE)
# m = 1
Ax = 0
Ay = 0
Bx = 100
By = 100
# m = 2.5
Ax = 20
Ay = 20
Bx = 60
By = 120
#m indeterminado (x2-x1)=0
Ax = 20
Ay = 30
Bx = 20
By = 80
'''
libreria1.makePlane()
libreria1.makeCircle(libreria1.Transform([Ax, Ay]), 1, AZUL)
libreria1.makeCircle(libreria1.Transform([Bx, By]), 1, AZUL)
Bresenham(Ax, Ay, Bx, By)
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
#Cardioide: r = a(1+cos(t))
# x = r cos (theta)
# y = r sen (theta)
a = 50
for t in range (0,360):
#pasarlos a radianes
r = a * (1 - math.cos(libreria1.DegToRad(t)))
#pasarlos a cartesianas
x = r*math.cos(libreria1.DegToRad(t))
y = r*math.sin(libreria1.DegToRad(t))
libreria1.makeCircle(libreria1.Transform([int(x),int(y)]),1)
'''
reloj = pygame.time.Clock()
r = 50
libreria1.makeCircle(libreria1.Transform([0, 0]), r,
ROJO) #dibuja el circulo fijo
for t in range(0, 360):
x = r * math.cos(libreria1.DegToRad(t))
y = r * math.sin(libreria1.DegToRad(t))
reloj.tick(150)
libreria1.makeCircle(libreria1.Transform([int(x), int(y)]), 2 * r, VERDE)
reloj.tick(150)
libreria1.makeCircle(libreria1.Transform([int(x), int(y)]), 1, BLANCO)
reloj.tick(150)
libreria1.makeCircle(libreria1.Transform([int(x), int(y)]), 2 * r, NEGRO)
x2 = 3 * r * math.cos(libreria1.DegToRad(t))
y2 = 3 * r * math.sin(libreria1.DegToRad(t))
libreria1.makeCircle(libreria1.Transform([int(x2) + 1, int(y2)]), 1, ROJO)
'''centro_circulo = [100,0]
puntos = []
