def dessin(self, point1, point2, pointpiste1, pointpiste2, nb):
#dessin de ligne de carrés entre point1 et point2
Deltax, Deltay = (point1.x - point2.x), (point1.y - point2.y)
deltax, deltay = pointpiste1.x - pointpiste2.x, pointpiste1.y - pointpiste2.y
v = math.sqrt(deltax**2 + deltay**2)
V2 = LARGEUR / 10
pen = QPen(QtGui.QColor('white'), V2)
pen.setCapStyle(Qt.SquareCap)
pen.setJoinStyle(Qt.RoundJoin)
if v != 0:
deltax, deltay = deltax / v, deltay / v
if nb == 1:
for i in range(1, 5):
P1 = piste.Point(point1.x - i * Deltax / 5,
point1.y - i * Deltay / 5)
P2 = piste.Point(point1.x - i * Deltax / 5 + V2 * deltax * 0.5,
point1.y - i * Deltay / 5 + V2 * deltay * 0.5)
self.scene.addLine(P1.x, P1.y, P2.x, P2.y, pen)
else:
for i in range(5):
P1 = piste.Point(point1.x - (2 * i + 1) * Deltax / 10,
point1.y - (2 * i + 1) * Deltay / 10)
P2 = piste.Point(
point1.x - (2 * i + 1) * Deltax / 10 + V2 * deltax * 0.5,
point1.y - (2 * i + 1) * Deltay / 10 + V2 * deltay * 0.5)
self.scene.addLine(P1.x, P1.y, P2.x, P2.y, pen)
def extrem(self, nb):
#création de nb lignes de carrés à l'arrivée et au départ
deltax, deltay = self.piste[nb + 1].x - self.piste[0].x, self.piste[
nb + 1].y - self.piste[0].y
dx, dy = self.piste[-(nb + 2)].x - self.piste[-1].x, self.piste[-(
nb + 2)].y - self.piste[-1].y
self.dessin(self.chemin[1][0], self.chemin[2][0], self.piste[0],
self.piste[nb + 1], 1)
self.dessin(self.chemin[1][-1], self.chemin[2][-1], self.piste[-1],
self.piste[-(nb + 2)], 1)
for i in range(1, nb):
Pi = piste.Point(self.chemin[2][0].x + i * deltax / nb,
self.chemin[2][0].y + i * deltay / nb)
P1, P2 = self.dessininter(self.chemin[1][0], self.chemin[2][0], Pi)
self.dessin(P1, P2, self.piste[0], self.piste[nb + 1], (i + 1) % 2)
Pi2 = piste.Point(self.chemin[2][-1].x + i * dx / nb,
self.chemin[2][-1].y + i * dy / nb)
P3, P4 = self.dessininter(self.chemin[1][-1], self.chemin[2][-1],
Pi2)
self.dessin(P3, P4, self.piste[-1], self.piste[-(nb + 2)],
(i + 1) % 2)
def initUI(self): # Initialisation de l'interface graphique
self.setWindowTitle('Dessin Piste')
self.label = QLabel(self)
self.label.setText("Dessiner en maintenant shift + clic puis valider Click droit supprime le dernier point")
self.button = QPushButton('Ok', self)
self.button.clicked.connect(self.valide)
self.label.move(self.width() / 2 - 250, 0)
self.button.move((self.width() / 2) + 400, 0)
self.pointsm = [piste.Point(0, 0)] # liste des points milieux subdiviser
self.pointsg = [] # liste de points à gauche de l'axe de la piste subdiviser
self.pointsd = [] # liste de points à droite de l'axe de la piste subdiviser
self.angle = 0
self.nbrsection = 0
self.largeur = piste.LARGEUR
self.pos = None
self.pointsmclick = [piste.Point(-piste.PAS, 0), piste.Point(0, 0)] # liste des points milieux cliquer
self.pointsgclick = [piste.Point(-piste.PAS, self.largeur / 2)] # liste de points à gauche de l'axe de la piste cliquer
self.pointsdclick = [piste.Point(-piste.PAS, -self.largeur / 2)] # liste de points à droite de l'axe de la piste cliquer
def sectionner(self,oldpoint,newpoint): #Fonction qui decoupe un segment en plusieur segment
deltax, deltay = newpoint.x - oldpoint.x, newpoint.y - oldpoint.y
if deltax !=0:
coeff_directeur = deltay / deltax
b = newpoint.y - coeff_directeur * newpoint.x
pas = deltax / self.nbrsection
liste = []
for i in range(1, self.nbrsection):
x = oldpoint.x + i * pas
point = piste.Point(x, coeff_directeur * x + b)
liste.append(point)
liste.append(newpoint)
else:
pas = deltay / self.nbrsection
liste = []
for i in range(1, self.nbrsection):
point = piste.Point(oldpoint.x, oldpoint.y + i * pas)
liste.append(point)
liste.append(newpoint)
return liste
def newposition(currentnode):
print('dend = ' + str(current_node.dend))
#deltavirage = voit.calculdeltavirage(currentnode.vitesse)
deltavirage = 5
#print(deltavirage)
for vir in range(-deltavirage, deltavirage + 1):
newdirection = currentnode.direction + vir * voit.pasvirage
for acc in range(-voit.deltaacc, voit.deltaacc + 1):
newacceleration = currentnode.acceleration + acc * voit.pasacceleration
newvitesse = currentnode.vitesse + PASDETEMPS * currentnode.acceleration
if abs(newvitesse) > voit.vitessemax:
newvitesse = voit.vitessemax * np.sign(newvitesse)
newposition = currentnode.position + piste.Point(
-newvitesse * PASDETEMPS * np.sin(newdirection),
newvitesse * PASDETEMPS * np.cos(newdirection))
if abs(newvitesse) < abs(current_node.vitesse):
print('OK')
ligne = LineString([(currentnode.position.x,
currentnode.position.y),
(newposition.x, newposition.y)])
if (polygon.contains(Point(newposition.x, newposition.y)) and
(not ligned.intersects(ligne)
or not ligneg.intersects(ligne))
) or ligne.intersects(lignefin):
temps = currentnode.temps + 1
#print(temps)
dstart = currentnode.dstart + newvitesse * PASDETEMPS
if current_node.indexdend + 20 >= len(chemin[0]):
indexdend = len(chemin[0]) - 1
else:
indexdend = current_node.indexdend + 20
while indexdend > 0 and chemin[0][indexdend].distance(
newposition) > 2 * piste.LARGEUR:
indexdend -= 1
dend = chemin[0][indexdend].distance(
newposition) + longueur.get(indexdend)
couttot = dstart + dend
newnode = Node(newvitesse, newacceleration, newdirection,
temps, dstart, dend, couttot, indexdend,
currentnode, newposition)
heappush(heap, (newnode.couttot, newnode))
def mousePressEvent(self, event): #Evenement clic de la souris
if event.button() == Qt.LeftButton: #teste le bouton gauche est appuyé
if QApplication.keyboardModifiers() == Qt.ShiftModifier: #teste le bouton shift
newpoint = piste.Point(event.x(), event.y()) # récuperer le point cliqué
if newpoint.x != self.pointsmclick[-1].x or newpoint.y != self.pointsmclick[-1].y: # teste si on clique pas deux fois au même endroit
self.pointsmclick.append(newpoint)
if len(self.pointsmclick) == 3: #ajoute les premiers point gauche et droite
self.angle = affichage.call_angle(piste.Point(1, 0), self.pointsmclick[-2], self.pointsmclick[-1])
self.pointsgclick.append(piste.Point(self.pointsmclick[-2].x + (self.largeur / 2) * math.sin(self.angle),self.pointsmclick[-2].y - (self.largeur / 2) * math.cos(self.angle)))
self.pointsdclick.append(piste.Point(self.pointsmclick[-2].x - (self.largeur / 2) * math.sin(self.angle),self.pointsmclick[-2].y + (self.largeur / 2) * math.cos(self.angle)))
self.pointsg.append(piste.Point(self.pointsmclick[-2].x + (self.largeur / 2) * math.sin(self.angle),self.pointsmclick[-2].y - (self.largeur / 2) * math.cos(self.angle)))
self.pointsd.append(piste.Point(self.pointsmclick[-2].x - (self.largeur / 2) * math.sin(self.angle),self.pointsmclick[-2].y + (self.largeur / 2) * math.cos(self.angle)))
if len(self.pointsmclick) > 3:
angle = affichage.call_angle(self.pointsmclick[-1], self.pointsmclick[-2], self.pointsmclick[-3])
if angle>0:
angle = math.pi - angle
elif angle<0:
angle = -(math.pi - abs(angle))
demi_angle = angle/2
self.angle += demi_angle
self.pointsgclick.append(piste.Point(self.pointsmclick[-2].x + (self.largeur / 2) * math.sin(self.angle), self.pointsmclick[-2].y - (self.largeur / 2) * math.cos(self.angle)))
self.pointsdclick.append(piste.Point(self.pointsmclick[-2].x - (self.largeur / 2) * math.sin(self.angle), self.pointsmclick[-2].y + (self.largeur / 2) * math.cos(self.angle)))
longueur = math.sqrt((self.pointsmclick[-2].x - self.pointsmclick[-3].x) ** 2 + (self.pointsmclick[-2].y - self.pointsmclick[-3].y) ** 2)
self.nbrsection = int(longueur // (piste.PAS))
self.pointsm += self.sectionner(self.pointsmclick[-3], self.pointsmclick[-2])
self.pointsg += self.sectionner(self.pointsgclick[-2], self.pointsgclick[-1])
self.pointsd += self.sectionner(self.pointsdclick[-2],self.pointsdclick[-1])
self.angle += demi_angle
self.update()
def dessininter(self, Point1, Point2, Point3):
#crée un quatrième point pour faire un losange
Deltax, Deltay = Point1.x - Point2.x, Point1.y - Point2.y
P4 = piste.Point(Point3.x + Deltax, Point3.y + Deltay)
return (Point3, P4)