def __init__(self, x1=0, y1=0, x2=0, y2=0):
self.__p1 = Ponto(x1, y1)
self.__p2 = Ponto(x2, y2)
self.__x1 = x1
self.__y1 = y1
self.__x2 = x2
self.__y2 = y2
def preencher_pontos():
global pontos
pontos = [Ponto(float("{0:.4f}".format((ponto_d.coord_x))),float("{0:.4f}".format((ponto_d.coord_y + (ponto_a.coord_y - ponto_d.coord_y)/2))))]
i = 1
while i < qtd_pontos:
pontos.append(Ponto(float("{0:.4f}".format((pontos[i-1].coord_x + (ponto_c.coord_x - ponto_d.coord_x)/grau))), float("{0:.4f}".format((ponto_d.coord_y + (ponto_a.coord_y - ponto_d.coord_y)/2)))))
i = i + 1
return pontos
def PosCasaMaisProxima(rato):
minDist = 1.18973149536e+4932
posCasa = Ponto(0, 0)
for casa in casas:
dist = math.hypot(casa.x - rato.x, casa.y - rato.y)
if (dist < minDist):
minDist = dist
posCasa.x = casa.x
posCasa.y = casa.y
return posCasa
def PosRatoMaisProximo():
minDist = 1.18973149536e+4932
posRato = Ponto(0, 0)
for rato in ratos:
dist = math.hypot(rato.x - gato.x, rato.y - gato.y)
if (dist < minDist):
minDist = dist
posRato.x = rato.x
posRato.y = rato.y
return posRato
def main ():
p1 = Ponto(5.0, 7.0)
p2 = Ponto(0.0, 0.0)
x = p1.getX()
y = p1.getY()
print( "(" + str(x) + ", " + str(y) + ")" )
p2.shift(4.0,12.0)
d = p1.distancia(p2)
print("Distancia = ", d)
def start(self, maxDias, maxHorarios, maxProf, maxDisc, maxLabs, qtPontos):
print("\nDefinindo pontos...")
for i in range(maxProf):
self.Prof[i + 1] = Ponto(i + 1, 1)
for i in range(maxDisc):
self.Disc[i + 1] = Ponto(i + 1, 2)
for i in range(maxDias):
self.Dias[i + 1] = Ponto(i + 1, 3)
for i in range(maxHorarios):
self.Horarios[i + 1] = Ponto(i + 1, 4)
for i in range(maxLabs):
self.Labs[i + 1] = Ponto(i + 1, 5)
self.setDistancias()
print("Caminho definido. Calculando probabilidades...")
for i in range(4):
self.probabilidade(i + 1)
print("Probabilidades calculadas com sucesso!\n")
def main():
p1 = Ponto(1.0, 1.0)
p2 = Ponto(0.0, 0.0)
print p1
print p2
x = p1.getX()
y = p1.getY()
print("(" + str(x) + ", " + str(y) + ")")
d = p1.distancia(p2)
print "Distancia = ", d
p2.shift(1.0, 1.0)
if p1 == p2:
print "Os pontos sao iguais"
l1 = Linha(p1, p2)
c = l1.comprimento()
print "Comprimento = ", c
def bezier_casteljau(pontos, t):
global globVector
num_points = len(pontos)
if num_points == 1:
globVector.append(pontos[0])
glVertex2f(pontos[0].coord_x, pontos[0].coord_y)
else:
updated_points = []
for i in range(0, num_points - 1):
p = Ponto(
(t * (pontos[i + 1].coord_x) + (1 - t) * (pontos[i].coord_x)),
(t * (pontos[i + 1].coord_y) + (1 - t) * (pontos[i].coord_y)))
updated_points.append(p)
bezier_casteljau(updated_points, t)
def main():
# Definindo as confgurações da tela:
Xmax = 500
Ymax = 500
# definção das dores de fundo:
corFundo = color_rgb(99, 33, 99)
# criação da tela em si:
win = GraphWin("Radar", Xmax, Ymax)
win.setBackground(corFundo)
# teste da rotina ponto:
Ponto(100, 100, Xmax, Ymax, 'red', 3, Win=win)
# definição da tela como interativa com o mouse
# fechavel com o botão do canto superior direito:
win.getMouse()
win.close()
def testeGetX(self):
ponto = Ponto(3,4)
self.assertTrue(ponto.getX() == 3)
self.assertFalse(ponto.getX() == 75)
def qualQuadrante(self):
A = Ponto(1, 2)
B = Ponto(-3, 4)
C = Ponto(-45, -6)
D = Ponto(34, -100)
self.assertTrue(A.qualQuadrante()==1)
self.assertTrue(B.qualQuadrante()==2)
self.assertTrue(C.qualQuadrante()==3)
self.assertTrue(D.qualQuadrante()==4)
def testeSetY(self):
ponto = Ponto(3,999999999)
ponto.setY(4)
self.assertTrue(ponto.getY() == 4)
def testeSetX(self):
ponto = Ponto(9999999,4)
ponto.setX(3)
self.assertTrue(ponto.getX() == 3)
from math import pi
from ponto import Ponto
class Circulo:
def __init__(self, centro, raio):
self.centro = centro
self.raio = raio
def area(self):
return pi * raio **2
def perimetro(self):
return 2 * pi * raio
if __name__ == '__main__':
ponto1 = Ponto(0, 0)
raio = 2
circulo = Circulo(ponto1, raio)
print("%.2f" % circulo.area())
print("{0:.2f}".format( circulo.area()))
#area = pi * r
fator = int(arquivo[3])
tam_quad = float(arquivo[5])
# tratando o caso do usuario entrar com um valor muito grande para o quadrado
if tam_quad > 600:
tam_quad = 600
# definindo tamanho da tela
window_h = 700
window_w = 700
# calculando a quantidade de pontos de controle da curva de bezier
qtd_pontos = grau + 1
# vértices do quadrado
ponto_a = Ponto(50.0, 50.0)
ponto_b = Ponto(ponto_a.coord_x + tam_quad, ponto_a.coord_y)
ponto_c = Ponto(ponto_a.coord_x + tam_quad, ponto_b.coord_y + tam_quad)
ponto_d = Ponto(ponto_a.coord_x, ponto_b.coord_y + tam_quad)
quadrado = [ponto_a, ponto_b, ponto_c, ponto_d]
limite = [ponto_a.coord_y, ponto_b.coord_y + tam_quad]
# esta funcao eh responsavel por calcular as coordenadas dos pontos de controle em funcao dos vertices do quadrado
def preencher_pontos():
global pontos
pontos = [Ponto(float("{0:.4f}".format((ponto_d.coord_x))),float("{0:.4f}".format((ponto_d.coord_y + (ponto_a.coord_y - ponto_d.coord_y)/2))))]
i = 1
while i < qtd_pontos:
pontos.append(Ponto(float("{0:.4f}".format((pontos[i-1].coord_x + (ponto_c.coord_x - ponto_d.coord_x)/grau))), float("{0:.4f}".format((ponto_d.coord_y + (ponto_a.coord_y - ponto_d.coord_y)/2)))))
def __init__(self, largura, altura, canto = Ponto()):
""" l -> largura; h -> altura; canto um ponto """
self.l = largura
self.h = altura
self.p = canto
from matriz import Matriz
from ponto import Ponto
from caixeiroViajante import *
from datetime import datetime
matriz = Matriz(24)
ponto1 = Ponto('A')
ponto2 = Ponto('B')
ponto3 = Ponto('C')
ponto4 = Ponto('D')
ponto5 = Ponto('E')
ponto6 = Ponto('F')
ponto7 = Ponto('G')
ponto8 = Ponto('H')
ponto9 = Ponto('I')
ponto10 = Ponto('J')
ponto11 = Ponto('K')
ponto12 = Ponto('L')
ponto13 = Ponto('M')
ponto14 = Ponto('N')
ponto15 = Ponto('O')
ponto16 = Ponto('P')
ponto17 = Ponto('Q')
ponto18 = Ponto('R')
ponto19 = Ponto('S')
ponto20 = Ponto('T')
ponto21 = Ponto('U')
ponto22 = Ponto('V')
ponto23 = Ponto('X')
ponto24 = Ponto('Y')
from ponto import Ponto
from quadrado import Quadrado
if __name__ == '__main__':
p1 = Ponto(1, 2)
p2 = Ponto(4, 4)
quadrado = Quadrado(p1, p2)
lista = [1, 2, 3, 4]
lista[0] = 10
print(quadrado.area())
print(lista)
#l1 = Ponto.avacalhador_de_listas(tuple(lista))
#print(lista)
l1 = Ponto.avacalhador_de_listas(lista.copy())
print(lista)
#l1 = Ponto.avacalhador_de_listas(lista)
print(lista)
print(l1)
import random
import time
import tkinter
from gato import Gato
from ponto import Ponto
tk = tkinter.Tk()
canvas = tkinter.Canvas(tk, width=800, height=800)
canvas.pack()
gatos = [Gato(canvas, random.randint(0, 800), random.randint(0, 800))]
ultimoClick = Ponto(0, 0)
#Função de callback para quando clicar com o Mouse
def callback(event):
ultimoClick.x = event.x
ultimoClick.y = event.y
canvas.bind("<Button-1>", callback)
ultimoTempo = time.time()
while 1:
diffTime = int((time.time() - ultimoTempo) * 500)
ultimoTempo = time.time()
for gato in gatos:
gato.update(canvas, diffTime / 1000, ultimoClick)
tk.update()
time.sleep(0.03)
class Window(object):
def __init__(self, minimo_x, minimo_y, maximo_x, maximo_y):
self.min = Ponto(minimo_x, minimo_y)
self.max = Ponto(maximo_x, maximo_y)
def setCoordenadasMinimo(self, x, y):
self.min.set_x(x)
self.min.set_y(y)
def setCoordenadasMaximo(self, x, y):
self.max.set_x(x)
self.max.set_y(y)
def getXMin(self):
return self.min.get_x()
def getXMax(self):
return self.max.get_x()
def getYMin(self):
return self.min.get_y()
def getYMax(self):
return self.max.get_y()
def __init__(self, minimo_x, minimo_y, maximo_x, maximo_y):
self.min = Ponto(minimo_x, minimo_y)
self.max = Ponto(maximo_x, maximo_y)
gato = Gato(canvas, random.randint(0, 800), random.randint(0, 800))
ratos = [
Rato(canvas, random.randint(0, 800), random.randint(0, 800)),
Rato(canvas, random.randint(0, 800), random.randint(0, 800)),
Rato(canvas, random.randint(0, 800), random.randint(0, 800)),
Rato(canvas, random.randint(0, 800), random.randint(0, 800)),
Rato(canvas, random.randint(0, 800), random.randint(0, 800)),
Rato(canvas, random.randint(0, 800), random.randint(0, 800))
]
casas = []
continua = True
ultimoClick = Ponto(0, 0)
#------------------------------------------------------------------------
def CriaCasa():
if len(casas) < 5:
casas.append(Casa(canvas, ultimoClick.x, ultimoClick.y))
#------------------------------------------------------------------------
#Função de callback para quando clicar com o Mouse
def callback(event):
if continua:
ultimoClick.x = event.x
ultimoClick.y = event.y
from matriz import Matriz
from ponto import Ponto
from caixeiroViajante import *
from datetime import datetime
matriz = Matriz(9)
ponto1 = Ponto('A')
ponto2 = Ponto('B')
ponto3 = Ponto('C')
ponto4 = Ponto('D')
ponto5 = Ponto('E')
ponto6 = Ponto('F')
ponto7 = Ponto('G')
matriz.inserirElemento(0,0,ponto1)
matriz.inserirElemento(6,1,ponto2)
matriz.inserirElemento(3,2,ponto3)
matriz.inserirElemento(2,5,ponto4)
matriz.inserirElemento(5,6,ponto5)
matriz.inserirElemento(1,7,ponto6)
matriz.inserirElemento(4,8,ponto7)
print("Problema bitônico euclidiano do caixeiro-viajante:")
matriz.mostrarMatriz(matriz) #Print da matriz
print(" ")
# Registra o momento antes da execução do algoritmo
t0 = datetime.now()
# Roda o algoritmo 10 vezes
def perim(self):
""" Calcula o perímetro do retângulo. """
return (2 * self.a) + (2 * self.l)
def area(self):
""" Calcula a área do retângulo. """
return self.a * self.l
def isSquare(self):
""" Discrimina retângulos de quadrados. """
return (self.a == self.l)
def whichPoint(self):
"""Printa o ponto de cada retângulo. """
print(self.p)
a = Ponto(3, 5)
r = Rectangle(10, 5, a)
print(r.perim()) #output: 30
print(r.area()) #output: 50
print(r.isSquare()) #output: False
r.whichPoint()
b = Ponto(8, 7)
p = Rectangle(5, 5, b)
print(p.isSquare()) #output: True
p.whichPoint()
- altura, do tipo float
- canto, do tipo Ponto.
"""
def __init__(self, largura, altura, canto = Ponto()):
""" l -> largura; h -> altura; canto um ponto """
self.l = largura
self.h = altura
self.p = canto
def area(self):
""" Cálculo da área do retângulo """
a = self.l * self.h
return a
def perimetro(self):
""" Cálculo do perímetro do retângulo """
p = 2 * self.l + 2 * self.h
return p
def ponto_canto(self):
""" Printa o ponto do canto inferior esquerdo do retângulo"""
print(self.p)
p = Ponto(6,12)
r = Retangulo(18,30,p)
print("Área de um retângulo de lado 18cm e altura 30cm: ", r.area())
print("Perímetro deste mesmo restângulo: ", r.perimetro())
r.ponto_canto()
def __init__(self, altura, largura, pp=Ponto()):
""" Inicializa com a, l e um ponto, o novo retângulo criado pela classe. """
self.a = altura
self.l = largura
self.p = pp
from minimosquadradoslinear import MinimosQuadradosLinear
from ponto import Ponto
if __name__ == "__main__":
quantidadePontos = int(input("Informe a quantidade de pontos: "))
listaPontos = []
for i in range(quantidadePontos):
x = float(input("X: "))
y = float(input("Y: "))
ponto = Ponto(x, y)
listaPontos.append(ponto)
minimoQuadradoLinear = MinimosQuadradosLinear(listaPontos)
print()
print("Funcao: ", minimoQuadradoLinear.getFuncao())
def testeGetY(self):
ponto = Ponto(6,7)
self.assertTrue(ponto.getY() == 7)
self.assertFalse(ponto.getY() == 98)
xP1 = self.getP1().getX()
xO = O.getX()
xP2 = self.getP2().getX()
yP2 = self.getP2().getY()
yO = O.getY()
yP1 = self.getP1().getY()
return (xP1 <= xO and xO <= xP2 and (yP2 <= yO and yO <= yP1))
p1 = Ponto(5, 6)
p2 = Ponto(11, 4)
q = Quadrilatero(p1, p2)
o = Ponto(8, 5)
res = q.contidoEmQ(o)
print(res)
a = Ponto(2, 2)
sol = q.contidoEmQ(a)
from datetime import datetime
driver = webdriver.Chrome(
'C:/Users/Gisela/Desktop/python/robo_alocacao_horas/chromedriver/chromedriver'
)
driver.maximize_window()
os.system('cls')
# Obtém as datas automaticamente
# Informa as datas manualmente:
print('Dia (DD/MM): ')
dia = str(input())
data = str('2020-' + str(dia)[3:5] + '-' + str(dia)[0:2])
p = Ponto(driver, str(dia))
p.abrirPagina()
hrsTotal = p.calcularHorasTrabalhadas()
if (p.validaPeriodo()):
driver.find_element_by_tag_name('body').send_keys(Keys.CONTROL + 't')
# Tempo para alocar no Ticket JS-1 (Minutos em outras atividades)
print('Minutos em JS-1 (Shared): ')
tempoJS1 = int(input())
# Tempo para alocar no Ticket JS-117 (Minutos em reuniões)
print('Minutos em JS-117 (Reunioes): ')
tempoJS117 = int(input())
# abre a aba do jira
j = Jira(driver, str(data), p.obterPrimeiraEntrada(), hrsTotal, tempoJS1,
tempoJS117)
j.abrirPagina()
