From ae8894a7517020c8bfa3e0b39dbd1daa51435846 Mon Sep 17 00:00:00 2001 From: Daniel Carta <79732052+immortaldan10@users.noreply.github.com> Date: Wed, 3 Jul 2024 17:44:46 -0600 Subject: [PATCH] camelCase --- .DS_Store | Bin 0 -> 6148 bytes buttonEditor.py | 91 +++++++----- main.py | 378 +++++++++++++++++++++++------------------------- 3 files changed, 236 insertions(+), 233 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5cda457be8541b7de84b90156c0ed8d3cfe5b16e GIT binary patch literal 6148 zcmeHKOHRWu5PfbdXw?N>vO&rTB5{MXw2Ml>f*zo>DU?cS1N}&_%bq)M1Vp`#FkZ0H(8o6RY1NE0bMZim^rkc4i@$ZK&-Lb8td}2D4f7! zRg_x1TdPtukupbGpe1x&3w=yo_IzqghqCwpx`zov^xT;^~~Va0C6jFqkUm~M^z YfmDc*$IKynX!;{yWza$u_*Dfy00G2>;{X5v literal 0 HcmV?d00001 diff --git a/buttonEditor.py b/buttonEditor.py index cd12852..65c4f5e 100644 --- a/buttonEditor.py +++ b/buttonEditor.py @@ -6,34 +6,34 @@ from PySide6.QtGui import QPixmap, QMouseEvent, QPainter, QPen, QColor, QPainter from PySide6.QtCore import Qt, QPoint, QRect class ButtonEditor(QMainWindow): - def __init__(self, path_planner): + def __init__(self, pathPlanner): super().__init__() self.setWindowTitle("Button Editor") - self.path_planner = path_planner + self.pathPlanner = pathPlanner - self.image_label = QLabel(self) + self.imageLabel = QLabel(self) - script_dir = os.path.dirname(os.path.abspath(__file__)) - image_path = os.path.join(script_dir, "images", "Field.png") - self.pixmap = QPixmap(image_path) + scriptDir = os.path.dirname(os.path.abspath(__file__)) + imagePath = os.path.join(scriptDir, "images", "Field.png") + self.pixmap = QPixmap(imagePath) if self.pixmap.isNull(): - self.image_label.setText(f"Image not found at: {image_path}") + self.imageLabel.setText(f"Image not found at: {imagePath}") else: - self.image_label.setPixmap(self.pixmap) + self.imageLabel.setPixmap(self.pixmap) - self.path_planner_button = QPushButton("Main Window") - self.path_planner_button.clicked.connect(self.show_path_planner) - self.button_editor_button = QPushButton("Button Editor") - self.button_editor_button.clicked.connect(self.show_button_editor) + self.pathPlannerButton = QPushButton("Main Window") + self.pathPlannerButton.clicked.connect(self.showPathPlanner) + self.buttonEditorButton = QPushButton("Button Editor") + self.buttonEditorButton.clicked.connect(self.showButtonEditor) - button_layout = QHBoxLayout() - button_layout.addWidget(self.path_planner_button) - button_layout.addWidget(self.button_editor_button) + buttonLayout = QHBoxLayout() + buttonLayout.addWidget(self.pathPlannerButton) + buttonLayout.addWidget(self.buttonEditorButton) layout = QVBoxLayout() - layout.addLayout(button_layout) - layout.addWidget(self.image_label) + layout.addLayout(buttonLayout) + layout.addWidget(self.imageLabel) container = QWidget() container.setLayout(layout) @@ -41,30 +41,45 @@ class ButtonEditor(QMainWindow): self.resize(self.pixmap.width(), self.pixmap.height() + 60) - def show_button_editor(self): + # Variables + self.matchLength = 15 + self.TPS = 50 + self.matchTicks = self.matchLength * self.TPS + self.displayTickResolution = 4 + self.displayTicks = round(self.matchTicks / self.displayTickResolution) + + self.keyFrames = [] + + def addKeyFrames(self): + currentFrame = 0 + + for i in range(0, self.displayTicks): + self.keyFrames.append(currentFrame) + + def showButtonEditor(self): self.show() - self.path_planner.hide() + self.pathPlanner.hide() - def show_path_planner(self): + def showPathPlanner(self): self.hide() - self.path_planner.show() + self.pathPlanner.show() - def update_scene(self): + def updateScene(self): self.pixmap = QPixmap(os.path.join(os.path.dirname(os.path.abspath(__file__)), "images", "Field.png")) painter = QPainter(self.pixmap) - grey_pen = QPen(QColor(127, 127, 127)) - grey_pen.setWidth(2) - painter.setPen(grey_pen) + greyPen = QPen(QColor(127, 127, 127)) + greyPen.setWidth(2) + painter.setPen(greyPen) # Draw the Bezier curve segments - if self.path_planner.coordinates.size > 0: - for i in range(len(self.path_planner.coordinates) - 1): - start = QPoint(self.path_planner.coordinates[i][0], self.path_planner.coordinates[i][1]) - end = QPoint(self.path_planner.coordinates[i + 1][0], self.path_planner.coordinates[i + 1][1]) + if self.pathPlanner.coordinates.size > 0: + for i in range(len(self.pathPlanner.coordinates) - 1): + start = QPoint(self.pathPlanner.coordinates[i][0], self.pathPlanner.coordinates[i][1]) + end = QPoint(self.pathPlanner.coordinates[i + 1][0], self.pathPlanner.coordinates[i + 1][1]) - if i < len(self.path_planner.control_points): - control_pair = self.path_planner.control_points[i] + if i < len(self.pathPlanner.controlPoints): + controlPair = self.pathPlanner.controlPoints[i] pen = QPen(Qt.yellow) pen.setWidth(2) @@ -72,7 +87,7 @@ class ButtonEditor(QMainWindow): path = QPainterPath() path.moveTo(start) - path.cubicTo(control_pair[0], control_pair[1], end) + path.cubicTo(controlPair[0], controlPair[1], end) painter.drawPath(path) # Draw the nodes @@ -84,11 +99,11 @@ class ButtonEditor(QMainWindow): painter.setPen(Qt.NoPen) painter.setBrush(Qt.white) - for i, (x, y) in enumerate(self.path_planner.coordinates): - node_rect = QRect(x - self.path_planner.node_size // 6, y - self.path_planner.node_size // 6, - self.path_planner.node_size // 3, self.path_planner.node_size // 3) - painter.drawEllipse(node_rect) - painter.drawText(node_rect, Qt.AlignCenter, str(i + 1)) + for i, (x, y) in enumerate(self.pathPlanner.coordinates): + nodeRect = QRect(x - self.pathPlanner.nodeSize // 6, y - self.pathPlanner.nodeSize // 6, + self.pathPlanner.nodeSize // 3, self.pathPlanner.nodeSize // 3) + painter.drawEllipse(nodeRect) + painter.drawText(nodeRect, Qt.AlignCenter, str(i + 1)) painter.end() - self.image_label.setPixmap(self.pixmap) + self.imageLabel.setPixmap(self.pixmap) diff --git a/main.py b/main.py index 80a8a89..3ca80e5 100644 --- a/main.py +++ b/main.py @@ -14,35 +14,35 @@ class PathPlanner(QMainWindow): self.setWindowTitle("Auto Planner") self.coordinates = np.empty((0, 2), dtype=int) - self.control_points = [] - self.rotation_handles = [] - self.node_angles = [] + self.controlPoints = [] + self.rotationHandles = [] + self.nodeAngles = [] - self.image_label = QLabel(self) + self.imageLabel = QLabel(self) - script_dir = os.path.dirname(os.path.abspath(__file__)) - image_path = os.path.join(script_dir, "images", "Field.png") - self.pixmap = QPixmap(image_path) + scriptDir = os.path.dirname(os.path.abspath(__file__)) + imagePath = os.path.join(scriptDir, "images", "Field.png") + self.pixmap = QPixmap(imagePath) if self.pixmap.isNull(): - self.image_label.setText(f"Image not found at: {image_path}") + self.imageLabel.setText(f"Image not found at: {imagePath}") else: - self.image_label.setPixmap(self.pixmap) + self.imageLabel.setPixmap(self.pixmap) - self.main_window_button = QPushButton("Main Window") - self.main_window_button.clicked.connect(self.show_main_window) - self.button_editor_button = QPushButton("Button Editor") - self.button_editor_button.clicked.connect(self.show_button_editor) + self.mainWindowButton = QPushButton("Main Window") + self.mainWindowButton.clicked.connect(self.showMainWindow) + self.buttonEditorButton = QPushButton("Button Editor") + self.buttonEditorButton.clicked.connect(self.showButtonEditor) - button_layout = QHBoxLayout() - button_layout.addWidget(self.main_window_button) - button_layout.addWidget(self.button_editor_button) + buttonLayout = QHBoxLayout() + buttonLayout.addWidget(self.mainWindowButton) + buttonLayout.addWidget(self.buttonEditorButton) layout = QVBoxLayout() - layout.addLayout(button_layout) - layout.addWidget(self.image_label) + layout.addLayout(buttonLayout) + layout.addWidget(self.imageLabel) - self.button_editor = ButtonEditor(self) + self.buttonEditor = ButtonEditor(self) container = QWidget() container.setLayout(layout) @@ -52,185 +52,178 @@ class PathPlanner(QMainWindow): self.setMouseTracking(True) - self.last_click_pos = QPoint() + self.lastClickPos = QPoint() self.coordinates = np.empty((0, 2), dtype=int) - self.last_click_time = 0 - self.node_size = 35 - self.handle_size = 15 - self.rotation_handle_distance = 35 - self.control_points = [] - self.rotation_handles = [] - self.node_angles = [] - self.dragging_control_point = False - self.dragging_node = False - self.dragging_rotation_handle = False - self.dragging_control_point_index = (-1, -1) - self.dragging_node_index = -1 - self.dragging_rotation_handle_index = -1 + self.lastClickTime = 0 + self.nodeSize = 35 + self.handleSize = 15 + self.rotationHandleDistance = 35 + self.controlPoints = [] + self.rotationHandles = [] + self.nodeAngles = [] + self.draggingControlPoint = False + self.draggingNode = False + self.draggingRotationHandle = False + self.draggingControlPointIndex = (-1, -1) + self.draggingNodeIndex = -1 + self.draggingRotationHandleIndex = -1 - #Tells when either the left or right mouse button is pressed def mousePressEvent(self, event: QMouseEvent): - pos = self.image_label.mapFrom(self, event.position().toPoint()) + pos = self.imageLabel.mapFrom(self, event.position().toPoint()) x, y = pos.x(), pos.y() if 0 <= x < self.pixmap.width() and 0 <= y < self.pixmap.height(): if event.button() == Qt.RightButton: self.coordinates = np.vstack((self.coordinates, [x, y])) if len(self.coordinates) >= 2: - self.calculate_control_points() - self.calculate_rotation_handle_pos() - self.draw_scene() - self.button_editor.update_scene() + self.calculateControlPoints() + self.calculateRotationHandlePos() + self.drawScene() + self.buttonEditor.updateScene() elif event.button() == Qt.LeftButton: - current_time = event.timestamp() - if (current_time - self.last_click_time < 300 and - (pos - self.last_click_pos).manhattanLength() < 5): - node_index = self.is_point_in_node(x, y) - if node_index != -1: - self.delete_node(node_index) + currentTime = event.timestamp() + if (currentTime - self.lastClickTime < 300 and + (pos - self.lastClickPos).manhattanLength() < 5): + nodeIndex = self.isPointInNode(x, y) + if nodeIndex != -1: + self.deleteNode(nodeIndex) else: - control_point_index = self.is_point_in_control_point(x, y) - if control_point_index != (-1, -1): - self.smoothPoints(control_point_index[0], control_point_index[1]) - self.draw_scene() - self.button_editor.update_scene() + controlPointIndex = self.isPointInControlPoint(x, y) + if controlPointIndex != (-1, -1): + self.smoothPoints(controlPointIndex[0], controlPointIndex[1]) + self.drawScene() + self.buttonEditor.updateScene() else: - control_point_index = self.is_point_in_control_point(x, y) - if control_point_index != (-1, -1): - self.dragging_control_point = True - self.dragging_control_point_index = control_point_index + controlPointIndex = self.isPointInControlPoint(x, y) + if controlPointIndex != (-1, -1): + self.draggingControlPoint = True + self.draggingControlPointIndex = controlPointIndex else: - node_index = self.is_point_in_node(x, y) - if node_index != -1: - self.dragging_node = True - self.dragging_node_index = node_index + nodeIndex = self.isPointInNode(x, y) + if nodeIndex != -1: + self.draggingNode = True + self.draggingNodeIndex = nodeIndex else: - rotation_handle_index = self.is_point_in_rotation_handle(x, y) - if rotation_handle_index != -1: - self.dragging_rotation_handle = True - self.dragging_rotation_handle_index = rotation_handle_index + rotationHandleIndex = self.isPointInRotationHandle(x, y) + if rotationHandleIndex != -1: + self.draggingRotationHandle = True + self.draggingRotationHandleIndex = rotationHandleIndex - self.last_click_time = current_time - self.last_click_pos = pos + self.lastClickTime = currentTime + self.lastClickPos = pos - #Deletes node - def delete_node(self, index): + def deleteNode(self, index): self.coordinates = np.delete(self.coordinates, index, axis=0) - if index < len(self.control_points): - del self.control_points[index] - if index > 0 and index < len(self.control_points): - del self.control_points[index - 1] - if index < len(self.rotation_handles): - del self.rotation_handles[index] - self.draw_scene() - self.button_editor.update_scene() + if index < len(self.controlPoints): + del self.controlPoints[index] + if index > 0 and index < len(self.controlPoints): + del self.controlPoints[index - 1] + if index < len(self.rotationHandles): + del self.rotationHandles[index] + self.drawScene() + self.buttonEditor.updateScene() def mouseMoveEvent(self, event: QMouseEvent): - if self.dragging_control_point: - pos = self.image_label.mapFrom(self, event.position().toPoint()) + if self.draggingControlPoint: + pos = self.imageLabel.mapFrom(self, event.position().toPoint()) x, y = pos.x(), pos.y() - curve_index, point_index = self.dragging_control_point_index - self.control_points[curve_index][point_index] = QPoint(x, y) - self.draw_scene() - self.button_editor.update_scene() - elif self.dragging_node: - pos = self.image_label.mapFrom(self, event.position().toPoint()) + curveIndex, pointIndex = self.draggingControlPointIndex + self.controlPoints[curveIndex][pointIndex] = QPoint(x, y) + self.drawScene() + self.buttonEditor.updateScene() + elif self.draggingNode: + pos = self.imageLabel.mapFrom(self, event.position().toPoint()) x, y = pos.x(), pos.y() - self.coordinates[self.dragging_node_index] = [x, y] - self.calculate_control_points() - self.calculate_rotation_handle_pos() - self.draw_scene() - self.button_editor.update_scene() - elif self.dragging_rotation_handle: - pos = self.image_label.mapFrom(self, event.position().toPoint()) + self.coordinates[self.draggingNodeIndex] = [x, y] + self.calculateControlPoints() + self.calculateRotationHandlePos() + self.drawScene() + self.buttonEditor.updateScene() + elif self.draggingRotationHandle: + pos = self.imageLabel.mapFrom(self, event.position().toPoint()) x, y = pos.x(), pos.y() - node_x, node_y = self.coordinates[self.dragging_rotation_handle_index] - dx = x - node_x - dy = y - node_y + nodeX, nodeY = self.coordinates[self.draggingRotationHandleIndex] + dx = x - nodeX + dy = y - nodeY angle = np.arctan2(dy, dx) - self.node_angles[self.dragging_rotation_handle_index] = angle + self.nodeAngles[self.draggingRotationHandleIndex] = angle - rotation_handle_x = int(node_x + self.rotation_handle_distance * np.cos(angle)) - rotation_handle_y = int(node_y + self.rotation_handle_distance * np.sin(angle)) - self.rotation_handles[self.dragging_rotation_handle_index] = QPoint(rotation_handle_x, rotation_handle_y) - self.draw_scene() - self.button_editor.update_scene() + rotationHandleX = int(nodeX + self.rotationHandleDistance * np.cos(angle)) + rotationHandleY = int(nodeY + self.rotationHandleDistance * np.sin(angle)) + self.rotationHandles[self.draggingRotationHandleIndex] = QPoint(rotationHandleX, rotationHandleY) + self.drawScene() + self.buttonEditor.updateScene() - #Resets dragging when mouse is released def mouseReleaseEvent(self, event: QMouseEvent): if event.button() == Qt.LeftButton: - self.dragging_control_point = False - self.dragging_control_point_index = (-1, -1) - self.dragging_node = False - self.dragging_node_index = -1 - self.dragging_rotation_handle = False - self.dragging_rotation_handle_index = -1 - self.button_editor.update_scene() + self.draggingControlPoint = False + self.draggingControlPointIndex = (-1, -1) + self.draggingNode = False + self.draggingNodeIndex = -1 + self.draggingRotationHandle = False + self.draggingRotationHandleIndex = -1 + self.buttonEditor.updateScene() - #These 3 are for distinguishing what the user is clicking - def is_point_in_rotation_handle(self, x, y): - for i, handle in enumerate(self.rotation_handles): - if (abs(x - handle.x()) <= self.handle_size // 2 and - abs(y - handle.y()) <= self.handle_size // 2): + def isPointInRotationHandle(self, x, y): + for i, handle in enumerate(self.rotationHandles): + if (abs(x - handle.x()) <= self.handleSize // 2 and + abs(y - handle.y()) <= self.handleSize // 2): return i return -1 - def is_point_in_control_point(self, x, y): - for i, control_pair in enumerate(self.control_points): - for j, control_point in enumerate(control_pair): - if (abs(x - control_point.x()) <= self.handle_size // 2 and - abs(y - control_point.y()) <= self.handle_size // 2): + def isPointInControlPoint(self, x, y): + for i, controlPair in enumerate(self.controlPoints): + for j, controlPoint in enumerate(controlPair): + if (abs(x - controlPoint.x()) <= self.handleSize // 2 and + abs(y - controlPoint.y()) <= self.handleSize // 2): return (i, j) return (-1, -1) - def is_point_in_node(self, x, y): - for i, (node_x, node_y) in enumerate(self.coordinates): - if (abs(x - node_x) <= self.node_size // 2 and - abs(y - node_y) <= self.node_size // 2): + def isPointInNode(self, x, y): + for i, (nodeX, nodeY) in enumerate(self.coordinates): + if (abs(x - nodeX) <= self.nodeSize // 2 and + abs(y - nodeY) <= self.nodeSize // 2): return i return -1 - #Calculating the handle positions - def calculate_control_points(self): + def calculateControlPoints(self): if len(self.coordinates) >= 2: x1, y1 = self.coordinates[-2] x2, y2 = self.coordinates[-1] - mid_x, mid_y = (x1 + x2) // 2, (y1 + y2) // 2 - self.control_points.append([ - QPoint(mid_x - (x2 - x1) // 4, mid_y - (y2 - y1) // 4), - QPoint(mid_x + (x2 - x1) // 4, mid_y + (y2 - y1) // 4) + midX, midY = (x1 + x2) // 2, (y1 + y2) // 2 + self.controlPoints.append([ + QPoint(midX - (x2 - x1) // 4, midY - (y2 - y1) // 4), + QPoint(midX + (x2 - x1) // 4, midY + (y2 - y1) // 4) ]) - def calculate_rotation_handle_pos(self): + def calculateRotationHandlePos(self): for i, (x, y) in enumerate(self.coordinates): - if i >= len(self.node_angles): - self.node_angles.append(np.pi) # Default angle for new nodes + if i >= len(self.nodeAngles): + self.nodeAngles.append(np.pi) # Default angle for new nodes - angle = self.node_angles[i] + angle = self.nodeAngles[i] - rotation_handle_x = int(x + self.rotation_handle_distance * np.cos(angle)) - rotation_handle_y = int(y + self.rotation_handle_distance * np.sin(angle)) + rotationHandleX = int(x + self.rotationHandleDistance * np.cos(angle)) + rotationHandleY = int(y + self.rotationHandleDistance * np.sin(angle)) - if i >= len(self.rotation_handles): - self.rotation_handles.append(QPoint(rotation_handle_x, rotation_handle_y)) + if i >= len(self.rotationHandles): + self.rotationHandles.append(QPoint(rotationHandleX, rotationHandleY)) else: - self.rotation_handles[i] = QPoint(rotation_handle_x, rotation_handle_y) + self.rotationHandles[i] = QPoint(rotationHandleX, rotationHandleY) - #Updates buttonEditor - def update_scene(self): - self.button_editor.update_scene(self.coordinates, self.control_points) + def updateScene(self): + self.buttonEditor.updateScene(self.coordinates, self.controlPoints) - #Draws the scene, big important function - def draw_scene(self): + def drawScene(self): self.pixmap = QPixmap(os.path.join(os.path.dirname(os.path.abspath(__file__)), "images", "Field.png")) painter = QPainter(self.pixmap) - grey_pen = QPen(QColor(127, 127, 127)) - grey_pen.setWidth(2) - painter.setPen(grey_pen) - for i, control_pair in enumerate(self.control_points): + greyPen = QPen(QColor(127, 127, 127)) + greyPen.setWidth(2) + painter.setPen(greyPen) + for i, controlPair in enumerate(self.controlPoints): if i < len(self.coordinates) - 1: start = QPoint(self.coordinates[i][0], self.coordinates[i][1]) end = QPoint(self.coordinates[i + 1][0], self.coordinates[i + 1][1]) @@ -241,29 +234,29 @@ class PathPlanner(QMainWindow): path = QPainterPath() path.moveTo(start) - path.cubicTo(control_pair[0], control_pair[1], end) + path.cubicTo(controlPair[0], controlPair[1], end) painter.drawPath(path) painter.setBrush(Qt.NoBrush) - for control_point in control_pair: + for controlPoint in controlPair: painter.setPen(QPen(QColor(127, 127, 127), 1, Qt.DashLine)) - painter.drawLine(start, control_point) - painter.drawLine(end, control_point) + painter.drawLine(start, controlPoint) + painter.drawLine(end, controlPoint) painter.setPen(Qt.NoPen) painter.setBrush(QColor(0, 255, 255)) - for control_point in control_pair: + for controlPoint in controlPair: painter.drawEllipse( - control_point.x() - self.handle_size // 2, - control_point.y() - self.handle_size // 2, - self.handle_size, - self.handle_size + controlPoint.x() - self.handleSize // 2, + controlPoint.y() - self.handleSize // 2, + self.handleSize, + self.handleSize ) painter.setBrush(Qt.NoBrush) for i, (x, y) in enumerate(self.coordinates): - if i < len(self.rotation_handles): - angle = self.node_angles[i] + if i < len(self.rotationHandles): + angle = self.nodeAngles[i] painter.save() painter.translate(x, y) @@ -273,8 +266,8 @@ class PathPlanner(QMainWindow): pen.setWidth(2) painter.setPen(pen) painter.setBrush(Qt.NoBrush) - painter.drawRect(-self.node_size // 2, -self.node_size // 2, - self.node_size, self.node_size) + painter.drawRect(-self.nodeSize // 2, -self.nodeSize // 2, + self.nodeSize, self.nodeSize) painter.restore() @@ -282,70 +275,65 @@ class PathPlanner(QMainWindow): font = painter.font() font.setPointSize(25) painter.setFont(font) - painter.drawText(QRect(x - self.node_size // 2, y - self.node_size // 2, - self.node_size, self.node_size), + painter.drawText(QRect(x - self.nodeSize // 2, y - self.nodeSize // 2, + self.nodeSize, self.nodeSize), Qt.AlignCenter, str(i + 1)) - for i, handle in enumerate(self.rotation_handles): + for i, handle in enumerate(self.rotationHandles): painter.setBrush(QColor(255, 0, 255)) painter.drawEllipse( handle, - self.handle_size // 2, - self.handle_size // 2 + self.handleSize // 2, + self.handleSize // 2 ) painter.setBrush(Qt.NoBrush) - self.image_label.setPixmap(self.pixmap) - self.button_editor.update_scene() + self.imageLabel.setPixmap(self.pixmap) + self.buttonEditor.updateScene() - #S M O O T H - def smoothPoints(self, curve_index: int, point_index: int): - if curve_index + 1 < len(self.control_points): - prev_control_pair = self.control_points[curve_index] - next_control_pair = self.control_points[curve_index + 1] - node = QPoint(self.coordinates[curve_index + 1][0], self.coordinates[curve_index + 1][1]) + def smoothPoints(self, curveIndex: int, pointIndex: int): + if curveIndex + 1 < len(self.controlPoints): + prevControlPair = self.controlPoints[curveIndex] + nextControlPair = self.controlPoints[curveIndex + 1] + node = QPoint(self.coordinates[curveIndex + 1][0], self.coordinates[curveIndex + 1][1]) - #Calculate the new position for the second control point - new_control2 = QPoint( - 2 * node.x() - next_control_pair[0].x(), - 2 * node.y() - next_control_pair[0].y() + newControl2 = QPoint( + 2 * node.x() - nextControlPair[0].x(), + 2 * node.y() - nextControlPair[0].y() ) - self.control_points[curve_index][1] = new_control2 + self.controlPoints[curveIndex][1] = newControl2 - #Calculate the new position for the first control point - new_control1 = QPoint( - 2 * node.x() - prev_control_pair[1].x(), - 2 * node.y() - prev_control_pair[1].y() + newControl1 = QPoint( + 2 * node.x() - prevControlPair[1].x(), + 2 * node.y() - prevControlPair[1].y() ) - self.control_points[curve_index + 1][0] = new_control1 + self.controlPoints[curveIndex + 1][0] = newControl1 - #Clears all - def clear_points(self): + def clearPoints(self): self.coordinates = np.empty((0, 2), dtype=int) - self.control_points.clear() - self.rotation_handles.clear() - self.node_angles.clear() - self.draw_scene() - self.button_editor.update_scene() + self.controlPoints.clear() + self.rotationHandles.clear() + self.nodeAngles.clear() + self.drawScene() + self.buttonEditor.updateScene() - #Warning for clearing - def show_clear_warning(self): + def showClearWarning(self): reply = QMessageBox.question(self, "Clear Auto", "Are you sure you want to clear this auto?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.Yes: - self.clear_points() + self.clearPoints() - def show_main_window(self): + def showMainWindow(self): self.show() - self.button_editor.hide() + self.buttonEditor.hide() - def show_button_editor(self): + def showButtonEditor(self): self.hide() - self.button_editor.show() + self.buttonEditor.show() if __name__ == "__main__": app = QApplication(sys.argv) window = PathPlanner() window.show() - sys.exit(app.exec()) \ No newline at end of file + sys.exit(app.exec())