Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0125· OpenAIAi2 WildChat-4.8M (AI2)

напиши мне диалоговое окно с возвращаемым ответом в pyside2

  1. User

    напиши мне диалоговое окно с возвращаемым ответом в pyside2

  2. Assistant

    Sure! Here is an example of a dialog window with a returnable answer using PySide2:

    import sys
    from PySide2.QtWidgets import QApplication, QDialog, QPushButton, QVBoxLayout, QLabel
    
    class DialogWindow(QDialog):
        def __init__(self):
            super(DialogWindow, self).__init__()
            
            layout = QVBoxLayout()
            self.label = QLabel("Are you sure you want to proceed?")
            layout.addWidget(self.label)
            
            self.yes_button = QPushButton("Yes")
            self.yes_button.clicked.connect(self.accept)
            layout.addWidget(self.yes_button)
            
            self.no_button = QPushButton("No")
            self.no_button.clicked.connect(self.reject)
            layout.addWidget(self.no_button)
            
            self.setLayout(layout)
    
        def get_answer(self):
            if self.exec_() == QDialog.Accepted:
                return True
            else:
                return False
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        dialog = DialogWindow()
        answer = dialog.get_answer()
        
        if answer:
            print("Proceeding with action")
        else:
            print("Canceling action")
        
        sys.exit(app.exec_())
    

    In this example, a dialog window is created with a question and two buttons (Yes and No). The get_answer method is used to display the dialog and return a boolean value based on the button clicked by the user. The answer is then used to determine the action to be taken.

  3. User

    Нет, мне нужно стандартное диалоговое окно

  4. Assistant

    Конечно, вот пример стандартного диалогового окна с возвращаемым ответом в PySide2:

    import sys
    from PySide2.QtWidgets import QApplication, QMessageBox
    
    def show_dialog():
        msg_box = QMessageBox()
        msg_box.setText("Are you sure you want to proceed?")
        msg_box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
        
        return msg_box.exec_() == QMessageBox.Yes
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        
        if show_dialog():
            print("Proceeding with action")
        else:
            print("Canceling action")
        
        sys.exit(app.exec_())
    

    В этом примере функция show_dialog создает стандартное диалоговое окно QMessageBox с вопросом и двумя кнопками (Yes и No). Затем функция возвращает True, если пользователь выбрал "Yes" и False, если пользователь выбрал "No". В основной части кода результат диалогового окна используется для определения следующего действия.

  5. User

    напиши мне стандартный диалог сохранения файла

  6. Assistant

    Конечно! Вот пример стандартного диалогового окна сохранения файла с помощью PySide2:

    import sys
    from PySide2.QtWidgets import QApplication, QFileDialog
    
    def save_file_dialog():
        options = QFileDialog.Options()
        file_name, _ = QFileDialog.getSaveFileName(None, "Save File", "", "All Files (*);;Text Files (*.txt)", options=options)
        
        if file_name:
            return file_name
        else:
            return None
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        
        file_path = save_file_dialog()
        
        if file_path:
            print("File saved to:", file_path)
        else:
            print("Save operation canceled")
        
        sys.exit(app.exec_())
    

    В этом примере функция save_file_dialog открывает стандартное диалоговое окно сохранения файла с возможностью задать фильтр для типов файлов. Если пользователь выбирает файл для сохранения, функция возвращает путь к файлу. В основной части кода результат диалогового окна используется для определения действия.

  7. User

    как в python проверить что атрибут присутствует в классе

  8. Assistant

    В Python вы можете использовать функцию hasattr() для проверки наличия атрибута в классе. Вот пример:

    class MyClass:
        def __init__(self, name):
            self.name = name
    
    obj = MyClass("example")
    
    if hasattr(obj, 'name'):
        print("Attribute 'name' is present in MyClass")
    else:
        print("Attribute 'name' is not present in MyClass")
    

    В этом примере мы создаем класс MyClass с атрибутом name в конструкторе. Затем мы создаем объект obj от этого класса и используем hasattr() для проверки наличия атрибута name в объекте. В зависимости от результата проверки будет выведено соответствующее сообщение.

  9. User

    Traceback (most recent call last): File "C:\Users\aleks\PycharmProjects\Diplom\Saver.py", line 62, in run self.writeToFile() File "C:\Users\aleks\PycharmProjects\Diplom\Saver.py", line 33, in writeToFile image = self.qpixmap_to_ndarray(self.pixmaps[i]) File "C:\Users\aleks\PycharmProjects\Diplom\Saver.py", line 49, in qpixmap_to_ndarray arr = arr.reshape((pixmap.height(), pixmap.width(), 3)) ValueError: cannot reshape array of size 1228800 into shape (480,640,3)

  10. Assistant

    Ошибка, которую вы получили, означает, что вы пытаетесь изменить форму массива на размер, который не соответствует его текущему размеру. В вашем случае, попытка изменить массив размером 1228800 элементов в массив размером (480, 640, 3) вызывает ошибку.

    Вы можете добавить проверку, чтобы убедиться, что размеры передаваемого массива и размеры Pixmap совпадают, прежде чем вы пытаетесь изменить его форму.

    Вот пример того, как вы можете это сделать:

    def qpixmap_to_ndarray(self, pixmap):
        image_format = QtGui.QImage.Format_ARGB32
        image = pixmap.toImage().convertToFormat(image_format)
    
        width = image.width()
        height = image.height()
        
        arr = image.bits().asstring(width * height * 4)
        arr = np.frombuffer(arr, np.uint8).reshape((height, width, 4))
        
        if arr.size == width * height * 4:
            arr = arr.reshape((height, width, 4))
            return arr
        else:
            print("Error: Incorrect array size")
            return None
    
    

    Добавив эту проверку, вы сможете избежать ошибки ValueError, связанной с несоответствием размеров массива при попытке изменения его формы.

  11. User

    какой диапазон секунд выбрать чтобы сохранять картинку, на которой распознан триггерный объект, чтобы это не сильно замедляло работу программы

  12. Assistant

    Оптимальный диапазон секунд для сохранения изображения с распознанным триггерным объектом зависит от конкретной задачи и требований к производительности вашей программы. Однако, обычно, рекомендуется выбирать частоту сохранения изображений на основе скорости обработки кадров вашей камеры и скорости обработки изображений вашим алгоритмом распознавания.

    Например, если ваша камера захватывает изображения со скоростью 30 кадров в секунду, и время обработки каждого изображения составляет 0.2 секунды, то можно выбрать диапазон сохранения в 1 секунду (каждое 6-е изображение) или 2 секунды (каждое 12-е изображение), чтобы не сильно замедлить работу программы.

    Однако, для улучшения производительности программы, также можно оптимизировать алгоритм распознавания объектов, использование многопоточности или распределенных вычислений для ускорения обработки изображений.

    Рекомендуется экспериментировать с разными частотами сохранения изображений и профилировать производительность вашей программы, чтобы найти оптимальное сочетание скорости обработки и сохранения изображений.

  13. User

    как сделать сохранение QPixmap так чтобы оно не замедляло основной поток

  14. Assistant

    Чтобы сохранение QPixmap не замедляло основной поток вашего приложения, вы можете использовать механизм многопоточности. Вам необходимо создать дополнительный поток для выполнения операции сохранения QPixmap, в то время как основной поток продолжает обработку данных.

    Вот пример того, как можно реализовать сохранение QPixmap в отдельном потоке с помощью модуля threading:

    import sys
    import time
    from PySide2.QtWidgets import QApplication, QWidget, QPushButton
    from PySide2.QtGui import QPixmap
    import threading
    
    class SaveThread(threading.Thread):
        def __init__(self, pixmap):
            threading.Thread.__init__(self)
            self.pixmap = pixmap
    
        def run(self):
            # Сохранить QPixmap
            self.pixmap.save("image.png")
    
    class MainWidget(QWidget):
        def __init__(self):
            super(MainWidget, self).__init__()
    
            self.button = QPushButton("Save Image", self)
            self.button.clicked.connect(self.save_image)
            
        def save_image(self):
            pixmap = QPixmap("image.jpg")
    
            save_thread = SaveThread(pixmap)
            save_thread.start()
    
    if __name__ == "__main__":
        app = QApplication(sys.argv)
        main_widget = MainWidget()
        main_widget.show()
        sys.exit(app.exec_())
    

    В данном примере, мы создаем дополнительный поток SaveThread для сохранения QPixmap в файл. После нажатия кнопки "Save Image", основной поток создает объект SaveThread и запускает его с помощью метода start(), в то время как основной поток продолжает свою работу.

    Пожалуйста, обратите внимание, что при работе с многопоточностью нужно быть осторожным с синхронизацией доступа к общим ресурсам, таким как переменные или данные.

  15. User

    def takeScreenShot(self, path): if self.imageSaveThread: if self.imageSaveThread.isRunning(): return self.imageSaveThread = ImageSaveThread(self.mediaView.getPixmap(), path) self.imageSaveThread.start() class ImageSaveThread(QThread): def init(self, pixmap, save_path): super().init() self.pixmap = pixmap self.save_path = save_path def run(self): self.pixmap.save(self.save_path) time.sleep(2) Почему то следующий код замедляет поток, хотя я сделал так, чтобы он брал картинку каждые 2 секунды через команду time.sleep(2)

  16. Assistant

    Проблема в вашем коде заключается в том, что вызов метода self.pixmap.save(self.save_path) блокирует основной поток исполнения программы до завершения операции сохранения изображения. Даже если вы используете time.sleep(2) внутри потока, блокирующие операции в основном потоке могут все еще замедлять работу приложения.

    Для того чтобы избежать блокировки основного потока, вам нужно разделить операцию сохранения изображения на несколько мелких шагов и выполнить их поэтапно. Например, воспользуйтесь событиями или сигналами, чтобы передать сигнал о том, что изображение сохранено.

    Вот пример, как можно изменить ваш код с использованием сигналов и слотов:

    from PySide2.QtCore import QThread, Signal
    
    class ImageSaveThread(QThread):
        imageSaved = Signal()
    
        def __init__(self, pixmap, save_path):
            super().__init__()
            self.pixmap = pixmap
            self.save_path = save_path
    
        def run(self):
            self.pixmap.save(self.save_path)
    
            # Послать сигнал о завершении сохранения изображения
            self.imageSaved.emit()
    

    Затем в вашем методе takeScreenShot вы можете подключить сигнал imageSaved к функции, которая будет вызываться после сохранения изображения:

    def takeScreenShot(self, path):
        if self.imageSaveThread:
            if self.imageSaveThread.isRunning():
                return
        self.imageSaveThread = ImageSaveThread(self.mediaView.getPixmap(), path)
        self.imageSaveThread.imageSaved.connect(self.onImageSaved)
        self.imageSaveThread.start()
    
    def onImageSaved(self):
        print("Image saved successfully")
    

    Это позволит вам сохранять изображение в фоновом потоке, без блокировки основного потока исполнения.

  17. User

    Почему следующий код выдает ошибку когда пытается записать видео, хотя если запустить запись вручную, то оно внезапно работает def _drawResults(self): self.removePixmapBoxItem() if not self.results: return scenPos = self.getSceneMediaPos() detectionClasses: BondingBoxes = self.settings.detectionClasses bondingPixmap = QPixmap(self.pixmapImageItem.pixmap().size()) bondingPixmap.fill(Qt.transparent) painter = QPainter(bondingPixmap) detectedClasses = [] for result in self.results: for box in result.boxes: if not detectionClasses.isClassEnabled(int(box.cls[0])): continue detectedClasses.append(int(box.cls[0])) x1, y1, x2, y2 = box.xyxy[0] x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2) w, h = x2 - x1, y2 - y1

                x1 = int(x1 + scenPos.x())  # Учитываем смещение изображения по оси x
                y1 = int(y1 + scenPos.y())
                w = int(w)
                h = int(h)
    
                _, name, width, color = detectionClasses.getClass(int(box.cls[0]))
    
                # Устанавливаем параметры окантовки
                pen = QPen(color)
                pen.setWidth(width)  # Задаем ширину окантовки
                painter.setPen(pen)
    
                rectangle = QRect(x1, y1, w, h)
    
                painter.drawRect(rectangle)
    
                pen = QPen(Qt.black)
    
                painter.setPen(pen)
                painter.setRenderHint(QPainter.Antialiasing)
    
                # Устанавливаем шрифт для текста
                font = QFont("Arial", 12)
                painter.setFont(font)
    
                painter.drawText(x1, y1, name)
    
        painter.end()
    
        self.pixmapBoxItem = QGraphicsPixmapItem(bondingPixmap)
        self.pixmapBoxItem.setZValue(1)
        self.scene.addItem(self.pixmapBoxItem)
    
        for detectedClass in detectedClasses:
            if detectedClass in self.settings.triggerClasses:
    
                #if self.settings.saveImageEnabled:
                    #self.saveScreenShot(os.path.join(self.settings.savePath,
                                                               #f"file_{datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}.{'png'}"))
                if self.settings.saveVideoEnabled:
                    self.saver.takeRecord(os.path.join(self.settings.savePath,
                                                               f"file_{datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}.{'mp4'}"),
                                          self.settings.saveDuration * 1000)
    

    def qpixmap_to_ndarray(self, pixmap): image = pixmap.toImage() if image.isNull(): return None

        image_format = QImage.Format_RGB32 if image.hasAlphaChannel() else QImage.Format_RGB888
        image = image.convertToFormat(image_format)
    
        arr = np.frombuffer(image.bits(), dtype=np.uint8)
    
        arr = arr.reshape((pixmap.height(), pixmap.width(), 4))
    
        return arr
    
  18. Assistant

    Когда вы пытаетесь записать видео с помощью self.saver.takeRecord() из вашего метода _drawResults(), возможно, что запись видео начинается раньше, чем ее рендеринг завершается. Это может вызвать проблему, так как видео должно быть записано только после того, как все необходимые кадры уже нарисованы и готовы для записи.

    Один из способов решения этой проблемы - использовать сигналы и слоты, чтобы убедиться, что запись видео произойдет только после того, как все рисование завершится. Вы можете отправить сигнал о завершении рисования и затем начать запись видео в обработчике этого сигнала.

    Вот примерно, как это может быть реализовано:

    from PySide2.QtCore import QObject, Signal
    
    class DrawingHandler(QObject):
        drawingFinished = Signal()
    
        def _drawResults(self):
            # ваш код для рисования результатов
            self.drawingFinished.emit()
    
    # Далее в вашем классе, где вы хотите использовать обработчик рисования:
    drawing_handler = DrawingHandler()
    drawing_handler.drawingFinished.connect(self.onDrawingFinished)
    
    def onDrawingFinished(self):
        if self.settings.saveVideoEnabled:
            self.saver.takeRecord(os.path.join(self.settings.savePath, f"file_{datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}.{'mp4'}"), self.settings.saveDuration * 1000)
    

    После того, как все кадры будут успешно нарисованы и сигнал drawingFinished будет отправлен, тогда будет запущена запись видео. Это позволит гарантировать, что запись видео начнется только после завершения рисования всех результатов.

    Также, убедитесь, что работа с памятью правильно управляется в вашем коде для предотвращения утечек памяти при работе с изображениями и видео.

  19. User

    Нет, он выдает следующую ошибку: Traceback (most recent call last): File "C:\Users\aleks\PycharmProjects\Diplom\Saver.py", line 63, in run self.writeToFile() File "C:\Users\aleks\PycharmProjects\Diplom\Saver.py", line 33, in writeToFile image = self.qpixmap_to_ndarray(self.pixmaps[i]) File "C:\Users\aleks\PycharmProjects\Diplom\Saver.py", line 49, in qpixmap_to_ndarray arr = arr.reshape((pixmap.height(), pixmap.width(), 3)) ValueError: cannot reshape array of size 1228800 into shape (480,640,3) При том, что эта ошибка не появляется в случае включения записи вручную

  20. Assistant

    Ошибку ValueError: cannot reshape array of size 1228800 into shape (480,640,3) обычно вызывает попытка изменить форму массива на размер, который не соответствует его текущему размеру.

    В вашем коде, вы обращаетесь к методу qpixmap_to_ndarray() для преобразования QPixmap в массив ndarray, однако, размеры изображения, полученного из pixmap.toImage(), не совпадают с ожидаемыми размерами (480x640x3).

    Чтобы избежать этой ошибки, вам необходимо проверить размеры изображения, прежде чем пытаться изменить его форму. Вы можете добавить проверку размеров в метод qpixmap_to_ndarray():

    def qpixmap_to_ndarray(self, pixmap):
        image = pixmap.toImage()
        if image.isNull():
            return None
    
        # Получаем размеры изображения
        width = image.width()
        height = image.height()
        channels = 3 # для RGB
    
        # Проверяем размеры изображения
        if width * height * channels != pixmap.width() * pixmap.height() * 4:
            print("Error: Incorrect array size")
            return None
    
        image_format = QImage.Format_RGB32 if image.hasAlphaChannel() else QImage.Format_RGB888
        image = image.convertToFormat(image_format)
    
        arr = np.frombuffer(image.bits(), dtype=np.uint8)
        arr = arr.reshape((height, width, channels))
    
        return arr
    

    Добавив проверку размеров изображения перед изменением его формы, вы сможете избежать ошибки ValueError и корректно преобразовать QPixmap в массив ndarray. Помните также, что формат пикселей может отличаться для разных изображений, поэтому учитывайте это при обработке данных.

  21. User

    Нет, в этом коде все нормально. Посмотри код полностью. Возможно ошибка связана с потоками и с массивом pixmaps: class RecordThread(QThread): stopByDuration = True writeInFile = False def init(self, mediaView, duration_ms, fps=24): super().init() self.mediaView = mediaView self.save_path = None self.duration_ms = duration_ms self.video_fps = fps

    def appendImage(self):
        self.cur_ms += 1000 // self.video_fps
    
        self.pixmaps.append(self.mediaView.getPixmap())
        time.sleep(1 / self.video_fps)
    
    def writeToFile(self):
        video_writer = cv2.VideoWriter(self.save_path, cv2.VideoWriter_fourcc(*'mp4v'), self.video_fps,
                                       (self.pixmaps[0].width(), self.pixmaps[0].height()))
        for i in range(len(self.pixmaps)):
            print(f"Записываю {self.pixmaps.index(self.pixmaps[i])}")
            image = self.qpixmap_to_ndarray(self.pixmaps[i])
            image_bgr = cv2.cvtColor(image, cv2.COLOR_RGBA2BGR)
            video_writer.write(image_bgr)
        video_writer.release()
    
    
    def qpixmap_to_ndarray(self, pixmap):
        image = pixmap.toImage()
        if image.isNull():
            return None
    
        image_format = QImage.Format_RGB32 if image.hasAlphaChannel() else QImage.Format_RGB888
        image = image.convertToFormat(image_format)
    
        arr = np.frombuffer(image.bits(), dtype=np.uint8)
    
        arr = arr.reshape((pixmap.height(), pixmap.width(), 3))
    
        return arr
    
    def run(self) -> None:
        self.pixmaps = []
        self.cur_ms = 0
        while self.cur_ms < self.duration_ms or not self.stopByDuration:
            self.appendImage()
    
        while not self.writeInFile:
            continue
    
        if self.save_path:
            self.writeToFile()
    

    class RecordThread_(QThread): def init(self, mediaView, duration_ms, fps=24, save_path=""): super().init() self.mediaView = mediaView self.save_path = save_path self.duration_ms = duration_ms self.cur_ms = 0 self.video_fps = fps self.images = [] self.rects = []

        self.stopByDuration = True
    def appendImage(self):
        self.cur_ms += 1000 // self.video_fps
    
        self.images.append(self.mediaView.getPixmap())
        time.sleep(1 / self.video_fps)
    
    def create_video_from_pixmaps(self, pixmap_list, video_filename, fps=24):
        video_writer = cv2.VideoWriter(video_filename, cv2.VideoWriter_fourcc(*'mp4v'), fps,
                                       (pixmap_list[0].width(), pixmap_list[0].height()))
    
        for i in range(len(pixmap_list)):
            print(f"Записываю {pixmap_list.index(pixmap_list[i])}")
            image = self.qpixmap_to_ndarray(pixmap_list[i])
            image_bgr = cv2.cvtColor(image, cv2.COLOR_RGBA2BGR)
            video_writer.write(image_bgr)
        video_writer.release()
    
    def qpixmap_to_ndarray(self, pixmap):
        image = pixmap.toImage()
        if image.isNull():
            return None
    
        image_format = QImage.Format_RGB32 if image.hasAlphaChannel() else QImage.Format_RGB888
        image = image.convertToFormat(image_format)
    
        arr = np.frombuffer(image.bits(), dtype=np.uint8)
    
        arr = arr.reshape((pixmap.height(), pixmap.width(), 3))
    
        return arr
    
    def run(self) -> None:
        #print("start record")
        while self.cur_ms < self.duration_ms or not self.stopByDuration:
            print(f"{self.cur_ms} {self.duration_ms}")
            self.appendImage()
        self.create_video_from_pixmaps(self.images, self.save_path)
    

    class ImageSaveThread(QThread): def init(self, pixmap, save_path): super().init() self.pixmap = pixmap self.save_path = save_path def run(self): self.pixmap.save(self.save_path) time.sleep(2)

    class Saver: recordThread = None takeRecordThread = None imageSaveThread = None def init(self, mediaView): self.mediaView = mediaView

    def getNewFileName(self, ext):
        return f"file_{datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}.{ext}"
    
    
    
    #def isRunning(self):
        #return self.recordThread.isRunning()
    
    def startRecord(self, fps=24):
        self.recordThread = RecordThread(self.mediaView,  0, fps=fps)
        self.recordThread.stopByDuration = False
        self.recordThread.start()
    
    
    def stopRecord(self):
        self.recordThread.stopByDuration = True
    def writeToFile(self, path):
        self.recordThread.save_path = path
        self.recordThread.writeInFile = True
    
    def abortRecord(self):
        self.recordThread.writeInFile = True
    
    def finish(self):
        if self.recordThread:
            if self.recordThread.isRunning():
                self.recordThread.stopByDuration = True
                self.recordThread.writeInFile = True
                self.recordThread.wait()
    
        if self.takeRecordThread:
            if self.takeRecordThread.isRunning():
                self.takeRecordThread.stopByDuration = True
                self.takeRecordThread.writeInFile = True
                self.takeRecordThread.wait()
    
        if self.imageSaveThread:
            if self.imageSaveThread.isRunning():
                self.imageSaveThread.wait()
    
    def takeScreenShot(self, path):
        if self.imageSaveThread:
            if self.imageSaveThread.isRunning():
                return
        self.imageSaveThread = ImageSaveThread(self.mediaView.getPixmap(), path)
        self.imageSaveThread.start()
    
    
    #Сомневаюсь, что он работает
    def takeRecord(self, path, duration_ms):
    
        if self.takeRecordThread:
            if self.takeRecordThread.isRunning():
                return
    
    
        self.takeRecordThread = RecordThread(self.mediaView, duration_ms)
        self.takeRecordThread.stopByDuration = True
        self.takeRecordThread.writeInFile = True
        self.takeRecordThread.save_path = path
        self.takeRecordThread.start()
    
  22. Assistant

    Ошибка ValueError: cannot reshape array of size 1228800 into shape (480,640,3) возникает, как уже упоминалось, из-за попытки изменения формы массива на размер, который не соответствует его текущему размеру.

    Проблема заключается в том, что один из ваших элементов pixmap имеет некорректный размер или формат, вызывая ошибку при передаче его в метод qpixmap_to_ndarray().

    Вам следует добавить проверку размера pixmap, прежде чем преобразовывать его в массив. Вот как это можно сделать:

    def qpixmap_to_ndarray(self, pixmap):
        if pixmap.isNull():
            return None
    
        image = pixmap.toImage()
        if image.isNull():
            return None
    
        target_width, target_height = 640, 480
        if pixmap.width() != target_width or pixmap.height() != target_height:
            print("Error: Incorrect pixmap dimensions")
            return None
    
        image_format = QImage.Format_RGB32 if image.hasAlphaChannel() else QImage.Format_RGB888
        image = image.convertToFormat(image_format)
    
        arr = np.frombuffer(image.bits(), dtype=np.uint8)
        arr = arr.reshape((target_height, target_width, 3))
    
        return arr
    

    Это позволит вам добавить дополнительную проверку на корректные размеры pixmap, прежде чем делать его преобразование в массив. Таким образом, вы избежите ошибки ValueError при попытке изменить размер массива.

  23. User

    Я понял, в чем проблема. После того как я складываю два pixmap-а, то почему то картинка становится больше: def getPixmap(self): def overlayImages(pixmap1, pixmap2): if not pixmap2: return pixmap1 result_pixmap = QPixmap(pixmap1.size()) result_pixmap.fill(Qt.transparent)

            painter = QPainter(result_pixmap)
            painter.drawPixmap(0, 0, pixmap1)
            painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
            painter.drawPixmap(0, 0, pixmap2)
            painter.end()
            return result_pixmap
        return overlayImages(self.getImagePixmap(), self.getBoxPixmap())
    
  24. Assistant

    Проблема возникает из-за того, что вы используете drawPixmap() метод для наложения изображений, и это приводит к увеличению размера изображения. Когда вы рисуете второе изображение поверх первого, оно перекрывает пиксели первого изображения, увеличивая размер пикселей.

    Для исправления этой проблемы, вы можете попробовать использовать метод setPixmap() для установки изображения на QPixmap, а не рисовать его поверх уже существующего изображения:

    def getPixmap(self):
        pixmap1 = self.getImagePixmap()
        pixmap2 = self.getBoxPixmap()
    
        if not pixmap2:
            return pixmap1
    
        result_pixmap = QPixmap(pixmap1.size())
        result_pixmap.fill(Qt.transparent)
    
        painter = QPainter(result_pixmap)
        painter.drawPixmap(0, 0, pixmap1)
        
        # Устанавливаем изображение pixmap2 поверх pixmap1
        pixmap2_scaled = pixmap2.scaled(pixmap1.size(), Qt.KeepAspectRatio)
        painter.drawPixmap(result_pixmap.rect(), pixmap2_scaled)
    
        painter.end()
    
        return result_pixmap
    

    В этом коде мы сначала масштабируем второе изображение pixmap2 так, чтобы оно соответствовало размеру исходного изображения pixmap1, а затем устанавливаем его поверх первого изображения с помощью метода drawPixmap(). Таким образом, размер изображения не будет изменяться при наложении второго изображения на первое.