Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

есть библиотека лучше zxing для распознания QR CODE

  1. User

    есть библиотека лучше zxing для распознания QR CODE

  2. Assistant

    Да, на сегодняшний день существует несколько библиотек, которые могут предложить альтернативы ZXing для распознавания QR-кодов. Вот некоторые из них:

    1. zbar: Это C-библиотека, которая также поддерживает сканирование QR-кодов. Она известна своей скоростью и поддерживает множество языков через обертки.

    2. QR Code Detector API (определяется вместе с OpenCV): OpenCV - мощная библиотека для компьютерного зрения, и в последних версиях она имеет встроенные функции для обнаружения и декодирования QR-кодов.

    3. Dynamsoft Barcode Reader: Это коммерческая библиотека, которая поддерживает широкий спектр форматов штрих-кодов и QR-кодов и предлагает высокую скорость и точность.

    4. Google ML Kit: Это мобильный SDK от Google, который включает возможности распознавания QR-кодов и штрих-кодов. Он оптимизирован для мобильных устройств.

    5. Barcode4j: Это другая Java-библиотека, которая поддерживает генерацию и распознавание штрих-кодов и QR-кодов.

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

  3. User

    что из списка ZXing , zbar, OpenCV качественнее определяет QR CODE

  4. Assistant

    Качество определения QR-кодов может зависеть от множества факторов, включая используемые алгоритмы, условия освещения, угол наклона, размер кода и настройку камеры. Тем не менее, вот несколько общих замечаний о каждой из этих библиотек:

    1. ZXing:

      • Преимущества: Хорошо зарекомендовавшая себя библиотека, широко используется, поддерживает множество форматов штрих-кодов, кросс-платформенная.
      • Недостатки: Иногда может быть медленнее или менее точно определять QR-коды в сложных условиях по сравнению с другими библиотеками.
    2. ZBar:

      • Преимущества: Известна своей высокой скоростью и эффективностью, особенно при работе с видео-потоками. Легко интегрируется на разных платформах через обертки.
      • Недостатки: Интерфейс может быть менее интуитивным, чем у некоторых других библиотек.
    3. OpenCV:

      • Преимущества: Очень мощная и гибкая библиотека для компьютерного зрения, поддерживает широкий спектр функций, включая распознавание QR-кодов. Хорошо работает в сложных условиях при правильной настройке.
      • Недостатки: Может иметь более сложную настройку для задач, связанных с распознаванием QR-кодов, по сравнению с специализированными библиотеками.

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

  5. User

    Приведи пример как распознать QR CODE на библиотеке OpenCV

  6. Assistant

    Определение и распознавание QR-кода с помощью OpenCV можно выполнить с использованием функций, встроенных в библиотеку начиная с версии 4.0. Ниже показан простой пример на Python, который загружает изображение, обнаруживает и декодирует QR-код:

    import cv2
    
    def decode_qr_code(image_path):
        # Загружаем изображение
        image = cv2.imread(image_path)
        
        # Создаем объект QRCodeDetector
        qr_decoder = cv2.QRCodeDetector()
    
        # Обнаруживаем и декодируем QR-код
        # detectAndDecode вернет кортеж из трех элементов: текст, координаты, прямоугольник
        decoded_text, points, _ = qr_decoder.detectAndDecode(image)
    
        if points is not None:
            # Если QR-код обнаружен, выводим декодированный текст
            print(f"Decoded text: {decoded_text}")
            
            # Рисуем линии, соединяющие углы QR-кода на изображении
            num_of_points = len(points)
            for i in range(num_of_points):
                next_point = i + 1 if i != num_of_points - 1 else 0
                cv2.line(image, tuple(points[i][0]), tuple(points[next_point][0]), (0, 255, 0), 3)
    
        else:
            print("QR code not detected")
        
        # Показать изображение с обозначенным QR-кодом
        cv2.imshow("Image", image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    
    # Путь к изображению с QR-кодом
    image_path = 'path_to_your_image_with_qrcode.jpg'
    decode_qr_code(image_path)
    

    Объяснение кода:

    1. Импорт библиотек: Основная библиотека — это OpenCV, которая используется для обработки изображений.
    2. Загрузка изображения: Используется cv2.imread() для загрузки изображения.
    3. Создание QRCodeDetector: Объект QRCodeDetector создается для обнаружения и декодирования QR-кодов.
    4. Обнаружение и декодирование: Метод detectAndDecode() обнаруживает и декодирует QR-код. Он возвращает текст, извлеченный из QR-кода, и массив координат углов QR-кода.
    5. Отображение результатов: Если QR-код найден, результат печатается, и углы QR-кода соединяются линиями на изображении для наглядности.

    Убедитесь, что на вашем компьютере установлена соответствующая версия OpenCV (opencv-python), которая поддерживает эту функциональность. Если OpenCV еще не установлен, его можно установить командой pip install opencv-python.

  7. User

    если входное изображение с QR CODE плохого качества, как обработать и улучшить для того чтобы библиотека с уверенностью его распознала

  8. Assistant

    Обработка изображений с плохим качеством, содержащих QR-коды, может сделать процесс распознавания более надежным. Вот несколько подходов, которые могут помочь улучшить качество входного изображения с QR-кодом перед попыткой его распознавания с помощью OpenCV:

    1. Грейскейл преобразование:

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

      • Используйте адаптивную бинаризацию (например, метод Оцу или адаптивный порог) для улучшения контрастности QR-кода относительно фона.
    3. Увеличение четкости (sharpness enhancement):

      • Используйте фильтры, такие как лапласиан для увеличения четкости изображения.
    4. Морфологическая обработка:

      • Применение морфологических операций, таких как открытие или закрытие, может помочь уменьшить шум или заполнить пробелы в структурах.
    5. Удаление шума:

      • Применение фильтров, таких как гауссово размытие, медианный фильтр, для удаления мелкого шума в изображении.
    6. Увеличение резкости (unsharp masking):

      • Этот метод может помочь повысить резкость контуров QR-кода.

    Вот пример, который включает некоторые из этих техник перед попыткой распознавания QR-кода:

    import cv2
    import numpy as np
    
    def preprocess_image(image):
        # Преобразуем изображение в градации серого
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    
        # Применяем размытие для сглаживания изображения и удаления шума
        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
    
        # Применяем адаптивную бинаризацию
        binary = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                       cv2.THRESH_BINARY, 11, 2)
    
        # Применяем морфологическое открытие для удаления артефактов
        kernel = np.ones((3, 3), np.uint8)
        processed_image = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
    
        return processed_image
    
    def decode_qr_code(image_path):
        # Загружаем исходное изображение
        image = cv2.imread(image_path)
    
        # Предобработка изображения
        processed_image = preprocess_image(image)
    
        # Создаем объект QRCodeDetector
        qr_decoder = cv2.QRCodeDetector()
    
        # Обнаруживаем и декодируем QR-код на предобработанном изображении
        decoded_text, points, _ = qr_decoder.detectAndDecode(processed_image)
    
        if points is not None:
            print(f"Decoded text: {decoded_text}")
        else:
            print("QR code not detected")
    
        # Показать предобработанное изображение
        cv2.imshow("Processed Image", processed_image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    
    # Путь к изображению с QR-кодом
    image_path = 'path_to_your_image_with_qrcode.jpg'
    decode_qr_code(image_path)
    

    Объяснение:

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

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

  9. User

    как загрузить несколько моделей YOLO в одном коде

  10. Assistant

    Загрузка и использование нескольких моделей YOLO в одном коде — это полезный прием, когда у вас есть разные модели, обученные для конкретных задач, и вы хотите использовать их вместе для анализа изображений. Это может быть полезно, например, для различных задач распознавания объектов на одном изображении. Ниже приведен пример того, как можно реализовать такой подход на Python с использованием OpenCV и YOLO.

    Шаги:

    1. Загрузите веса и конфигурации моделей YOLO.
    2. Создайте сети (net) для каждой модели.
    3. Обработайте изображение и примените каждую модель для детекции объектов.

    Вот пример кода, который показывает основные шаги:

    import cv2
    import numpy as np
    
    def load_yolo_model(weights_path, config_path, labels_path):
        net = cv2.dnn.readNet(weights_path, config_path)
        with open(labels_path, 'r') as f:
            labels = f.read().strip().split('\n')
        return net, labels
    
    def detect_objects(net, labels, image):
        (H, W) = image.shape[:2]
        blob = cv2.dnn.blobFromImage(image, 1/255.0, (416, 416), swapRB=True, crop=False)
        net.setInput(blob)
        layer_names = net.getLayerNames()
        layer_outputs = net.forward([layer_names[i - 1] for i in net.getUnconnectedOutLayers()])
    
        boxes, confidences, class_ids = [], [], []
        for output in layer_outputs:
            for detection in output:
                scores = detection[5:]
                class_id = np.argmax(scores)
                confidence = scores[class_id]
                if confidence > 0.5:
                    box = detection[0:4] * np.array([W, H, W, H])
                    (centerX, centerY, width, height) = box.astype("int")
                    x = int(centerX - (width / 2))
                    y = int(centerY - (height / 2))
                    
                    boxes.append([x, y, int(width), int(height)])
                    confidences.append(float(confidence))
                    class_ids.append(class_id)
    
        indices = cv2.dnn.NMSBoxes(boxes, confidences, 0.5, 0.4)
        results = []
        if len(indices) > 0:
            for i in indices.flatten():
                results.append({
                    "box": boxes[i],
                    "confidence": confidences[i],
                    "label": labels[class_ids[i]]
                })
        return results
    
    def process_image(image_path, yolo_models):
        image = cv2.imread(image_path)
        for net, labels in yolo_models:
            detections = detect_objects(net, labels, image)
            for det in detections:
                (x, y, w, h) = det["box"]
                label = f"{det['label']}: {det['confidence']:.2f}"
                cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
                cv2.putText(image, label, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
    
        cv2.imshow("Detections", image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()
    
    # Параметры для вашей первой модели YOLO
    weights_path_1 = "path_to_your_first_model.weights"
    config_path_1 = "path_to_your_first_model.cfg"
    labels_path_1 = "path_to_your_first_labels.txt"
    
    # Параметры для вашей второй модели YOLO
    weights_path_2 = "path_to_your_second_model.weights"
    config_path_2 = "path_to_your_second_model.cfg"
    labels_path_2 = "path_to_your_second_labels.txt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1, config_path_1, labels_path_1),
        load_yolo_model(weights_path_2, config_path_2, labels_path_2)
    ]
    
    # Путь к изображению
    image_path = "path_to_your_image.jpg"
    process_image(image_path, yolo_models)
    

    Объяснение:

    • Загрузка моделей: Функция load_yolo_model загружает и возвращает сеть и метки классов для данных весов и конфигурации YOLO.
    • Обработка изображений: Для каждого детектора в списке yolo_models, функция detect_objects обрабатывает изображение.
    • Рисование результатов: На изображении рисуются результаты для каждого обнаруженного объекта с использованием данных из каждой модели.

    Этот пример позволяет работать с разными моделями YOLO, простой заменой файлов весов, конфигурации и меток. Вы можете добавлять столько моделей, сколько нужно, просто добавляя их в список yolo_models.

  11. User

    модели в одном файле с расширением pt

  12. Assistant

    Если у вас несколько моделей YOLO, сохраненных в файлах с расширением .pt, это означает, что вы, вероятно, используете PyTorch или модели, полученные с помощью Ultralytics YOLOv5 или YOLOv8. Загрузка и использование нескольких таких моделей в одном скрипте несложна. Вот пример того, как это сделать с помощью PyTorch и библиотеки YOLOv5 от Ultralytics:

    Убедитесь, что вы установили библиотеку torch и yolov5 перед тем, как использовать следующий код:

    pip install torch torchvision torchaudio
    pip install yolov5
    

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

    import torch
    from yolov5 import YOLOv5
    
    def load_yolo_model(weights_path):
        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        model = YOLOv5(weights_path, device=device)
        return model
    
    def detect_objects(model, image_path):
        # Выполнение предсказания для изображения
        results = model.predict(image_path)
        return results
    
    def process_image(image_path, yolo_models):
        for model in yolo_models:
            results = detect_objects(model, image_path)
    
            # Печать результатов
            print(f"Results for model: {model.model.yaml['name']}")
            for result in results:
                print(f"Label: {result['label']}, Confidence: {result['confidence']:.2f}")
    
            # Отображение изображений с результатами (если вы хотите показать результаты)
            results.show()
    
    # Путь к весам для первой и второй модели
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению
    image_path = "path_to_your_image.jpg"
    process_image(image_path, yolo_models)
    

    Объяснение:

    • Загрузка моделей: Функция load_yolo_model загружает модель YOLO из файла с помощью YOLOv5 API от Ultralytics. Она использует CUDA, если она доступна на вашем устройстве.
    • Обработка изображений: Для каждого детектора в списке yolo_models, функция detect_objects выполняет предсказание для заданного изображения.
    • Вывод результатов: Результаты выводятся на экран, и вы можете визуализировать их с помощью метода .show().

    Этот код работает для YOLOv5, но методика может немного измениться, если вы используете другие модификации YOLO на основе PyTorch, так как структура модели может отличаться. Обязательно замените пути к файлам на соответствующие файлы .pt на вашем компьютере.

  13. User

    а если используется YOLOv8

  14. Assistant

    Для работы с моделями YOLOv8, разработанными командой Ultralytics, вы можете воспользоваться их библиотекой, которая обеспечивает простую API для предсказаний. Установка и запуск различных моделей YOLOv8 немного отличается, но она также весьма удобна.

    Вот как вы можете использовать несколько моделей YOLOv8, каждая из которых сохранена в формате .pt, в одном скрипте:

    1. Убедитесь, что библиотека ultralytics установлена. Вы можете сделать это, выполнив команду:

      pip install ultralytics
      
    2. Далее вы можете загрузить и использовать модели транспорта различным образом.

    Вот пример кода:

    from ultralytics import YOLO
    import cv2
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        return model
    
    def detect_objects(model, image):
        # Выполнение предсказания для изображения
        results = model(image)
        return results
    
    def process_image(image_path, yolo_models):
        # Загрузить изображения
        image = cv2.imread(image_path)
    
        for i, model in enumerate(yolo_models):
            results = detect_objects(model, image)
            
            # Отображение результатов для каждого объекта
            print(f"Results for model {i+1}:")
            for result in results:
                boxes = result.boxes.cpu().numpy()
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0]
                    confidence = box.conf[0]
                    class_id = box.cls[0]
                    
                    print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
            # Визуализация результатов
            results.show()
    
    # Путь к весам для первой и второй модели
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению
    image_path = "path_to_your_image.jpg"
    process_image(image_path, yolo_models)
    

    Объяснение:

    • Загрузка моделей: Мы используем класс YOLO из библиотеки Ultralytics, чтобы загрузить модели из файлов .pt.
    • Обработка изображений: Для каждой модели из списка yolo_models, функция detect_objects применяется к изображению и возвращает результаты предсказаний.
    • Визуализация и вывод результатов: После выполнения предсказаний результаты выводятся и визуализируются. Здесь model.names используется для получения имени класса из идентификатора.

    Этот код позволяет легко использовать несколько моделей YOLOv8 в одном скрипте и обрабатывать изображения для каждой модели последовательно, выводя и отображая соответствующие результаты.

  15. User

    Ошибка, исправь results.show() ^^^^^^^^^^^^ AttributeError: 'list' object has no attribute 'show'

  16. Assistant

    Ошибка возникает из-за того, что results является списком с результатами предсказания, и у этого объекта нет метода show(). Вместо этого мы можем использовать методы для визуализации результатов непосредственно из моделей YOLOv8 библиотеки Ultralytics. Давайте исправим это.

    Вот исправленный код:

    from ultralytics import YOLO
    import cv2
    import matplotlib.pyplot as plt
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        return model
    
    def detect_objects(model, image_path):
        # Выполнение предсказания для изображения
        results = model(image_path)
        return results
    
    def display_results(image_path, results):
        # Отображаем изображение с предсказаниями
        for result in results:
            # Используемся встроенные функции для визуализации
            result.plot()  # Это покажет изображение с нанесенными боксами
    
    def process_image(image_path, yolo_models):
        for i, model in enumerate(yolo_models):
            results = detect_objects(model, image_path)
            
            # Печать для каждого обнаруженного объекта
            print(f"Results for model {i+1}:")
            for result in results:
                boxes = result.boxes
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0]
                    confidence = box.conf[0]
                    class_id = box.cls[0]
                    
                    print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
            # Визуализация результатов через встроенную функцию
            display_results(image_path, results)
    
    # Путь к весам для первой и второй модели
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению
    image_path = "path_to_your_image.jpg"
    process_image(image_path, yolo_models)
    

    Объяснение:

    • Визуализация результатов: Метод plot() класса result используется для отображения изображения с предсказаниями, который корректно работает со списками результатов. Этот метод автоматически визуализирует изображения с нанесенными bounding boxes и другими важными деталями.
    • Цикл по results: Пробегаймся по каждому результату в results, чтобы распечатать информацию по объектам.

    Этот подход позволит вам корректно визуализировать результаты предсказаний для каждой модели YOLOv8. Если вам все еще нужно более явное управление, вы можете использовать другие библиотеки визуализации, такие как Matplotlib или OpenCV.

  17. User

    в место показа сделай сохранение в файл png

  18. Assistant

    Чтобы сохранить результаты предсказаний в файл изображения вместо их отображения на экране, мы можем использовать методы OpenCV для рисования прямоугольников и надписей на изображении, а затем сохранить измененное изображение с помощью cv2.imwrite(). Ниже представлен измененный код с функцией сохранения результатов:

    from ultralytics import YOLO
    import cv2
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        return model
    
    def detect_objects(model, image_path):
        results = model(image_path)
        return results
    
    def save_results(image_path, results, output_image_path):
        # Загружаем изображение
        image = cv2.imread(image_path)
        
        # Для каждого результата выполняем нанесение прямоугольников и меток
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                # Рисуем прямоугольник и добавляем текст
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        # Сохраняем изображение
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path):
        for i, model in enumerate(yolo_models):
            results = detect_objects(model, image_path)
    
            print(f"Processing with model {i+1}...")
            for result in results:
                boxes = result.boxes
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0]
                    confidence = box.conf[0]
                    class_id = box.cls[0]
    
                    print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
            output_image_path = f"{output_base_path}_model_{i+1}.png"
            save_results(image_path, results, output_image_path)
    
    # Путь к весам для первой и второй модели
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    process_image(image_path, yolo_models, output_base_path)
    

    Объяснение:

    • Запись изображения: Мы используем cv2.imwrite() для сохранения изображения после нанесения прямоугольников и меток. Это происходит в функции save_results.
    • Вывод в файл: Файлы сохраняются с именами output_image_model_1.png, output_image_model_2.png и т. д., в зависимости от модели, с которой были получены результаты.
    • Преобразование координат: Используется метод map(int, ...), чтобы преобразовать координаты Bounding Box из float в int, так как OpenCV требует целочисленных значений для координат.

    Этот модифицированный код будет сохранять результаты обработки изображений в файлах PNG вместо отображения их на экране.

  19. User

    в имени файла output_image добавь имя модели

  20. Assistant

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

    Вот как можно изменить код, чтобы включить имя модели в имя выходного файла:

    from ultralytics import YOLO
    import cv2
    import os
    
    def load_yolo_model(weights_path, model_name):
        model = YOLO(weights_path)
        model.name = model_name  # Сохраняем имя модели
        return model
    
    def detect_objects(model, image_path):
        results = model(image_path)
        return results
    
    def save_results(image_path, results, output_image_path):
        # Загружаем изображение
        image = cv2.imread(image_path)
        
        # Для каждого результата выполняем нанесение прямоугольников и меток
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                # Рисуем прямоугольник и добавляем текст
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        # Сохраняем изображение
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path):
        for model in yolo_models:
            results = detect_objects(model, image_path)
    
            print(f"Processing with model {model.name}...")
            for result in results:
                boxes = result.boxes
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0]
                    confidence = box.conf[0]
                    class_id = box.cls[0]
    
                    print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
            # Формируем имя файла на основе базового пути и имени модели
            model_name = model.name.replace(" ", "_")
            output_image_path = f"{output_base_path}_{model_name}.png"
            save_results(image_path, results, output_image_path)
    
    # Путь к весам и имена моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    model_name_1 = "first_model_name"
    model_name_2 = "second_model_name"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1, model_name_1),
        load_yolo_model(weights_path_2, model_name_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    process_image(image_path, yolo_models, output_base_path)
    

    Объяснение:

    • Имена моделей: Мы добавляем аргумент model_name в load_yolo_model и сохраняем имя модели как атрибут model.name.
    • Формирование имени файла: Используя model.name, мы создаем выходное имя файла, заменяя пробелы на подчеркивания для корректного именования файлов.
    • Сохранение: Изображения сохраняются с уникальными именами на основе имени модели, например, output_image_first_model_name.png.

    Убедитесь, что вы заменили model_name_1 и model_name_2 на реальные имена ваших моделей. Это делает выходные файлы более управляемыми и читаемыми.

  21. User

    имя модели возьми из weights_path_1 и weights_path_2 до .pt

  22. Assistant

    Хорошо, если мы хотим извлечь имя модели из пути к файлу, убрав все, что после последнего разделителя пути и до окончания .pt, мы можем использовать функции обработки строк и модуль os.path. Вот как это можно сделать:

    from ultralytics import YOLO
    import cv2
    import os
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]  # Извлекаем имя модели
        return model
    
    def detect_objects(model, image_path):
        results = model(image_path)
        return results
    
    def save_results(image_path, results, output_image_path):
        # Загружаем изображение
        image = cv2.imread(image_path)
        
        # Для каждого результата наносим прямоугольники и метки
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                # Рисуем прямоугольник и добавляем текст
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        # Сохраняем изображение
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path):
        for model in yolo_models:
            results = detect_objects(model, image_path)
    
            print(f"Processing with model {model.name}...")
            for result in results:
                boxes = result.boxes
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0]
                    confidence = box.conf[0]
                    class_id = box.cls[0]
    
                    print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
            # Формируем имя файла на основе базового пути и имени модели
            model_name = model.name.replace(" ", "_")
            output_image_path = f"{output_base_path}_{model_name}.png"
            save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    process_image(image_path, yolo_models, output_base_path)
    

    Объяснение:

    • Извлечение имени модели: Мы используем os.path.basename() для получения имени файла из пути, а затем os.path.splitext() для удаления расширения .pt. Это обеспечивает, что любое имя, предшествующее .pt, будет использовано как имя модели.
    • Сохранение результатов: Результаты сохраняются с именем файла, которое включает базовое имя из пути весов модели.

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

  23. User

    добавь вывод времени работы каждой модели

  24. Assistant

    Чтобы измерить время выполнения предсказаний для каждой модели, мы можем использовать модуль time из стандартной библиотеки Python. Это позволит нам определить, сколько времени требуется для обработки изображения каждой из моделей. Вот как можно внести соответствующие изменения в код:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        # Загружаем модель YOLO и извлекаем имя модели из пути к файлу
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        # Измеряем время выполнения предсказания
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        # Возвращаем результаты и время выполнения
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_image_path):
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path):
        for model in yolo_models:
            results, elapsed_time = detect_objects(model, image_path)
    
            print(f"Processing with model {model.name}...")
            print(f"Time taken: {elapsed_time:.2f} seconds")
            for result in results:
                boxes = result.boxes
                for box in boxes:
                    x1, y1, x2, y2 = box.xyxy[0]
                    confidence = box.conf[0]
                    class_id = box.cls[0]
    
                    print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
            model_name = model.name.replace(" ", "_")
            output_image_path = f"{output_base_path}_{model_name}.png"
            save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    process_image(image_path, yolo_models, output_base_path)
    

    Объяснение:

    • Использование time.time(): Время выполнения предсказания для каждой модели измеряется с помощью захвата временной метки до и после выполнения предсказания. Разница этих временных меток дает нам продолжительность выполнения.
    • Вывод времени: После выполнения предсказания код выводит время, которое потребовалось для обработки изображения данной моделью.

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

  25. User

    добавь сохранение результата в тестовый файл, в формате model, Time taken, Confidence

  26. Assistant

    Чтобы сохранять результаты в текстовый файл в формате model, Time taken, Confidence, необходимо выполнить запись этих данных в файл после выполнения предсказаний для каждой модели. Мы будем использовать функцию open() с режимом append, чтобы добавлять данные к текстовому файлу. Вот как можно изменить код для включения этой функции:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_image_path):
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for model in yolo_models:
                results, elapsed_time = detect_objects(model, image_path)
    
                print(f"Processing with model {model.name}...")
                print(f"Time taken: {elapsed_time:.2f} seconds")
                for result in results:
                    boxes = result.boxes
                    for box in boxes:
                        class_id = box.cls[0]
                        confidence = box.conf[0]
                        
                        # Записываем в файл подробности
                        f.write(f"{model.name}, {elapsed_time:.2f}, {confidence:.2f}\n")
    
                        print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                model_name = model.name.replace(" ", "_")
                output_image_path = f"{output_base_path}_{model_name}.png"
                save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_image(image_path, yolo_models, output_base_path, log_file)
    

    Объяснение:

    • Открытие файла: Используется open(log_file, 'a') для открытия файла в режиме добавления, что позволяет добавлять новые строки с каждым запуском без перезаписи предыдущих данных.
    • Запись данных: Для каждой модели и каждого результата добавляется запись в файл с указанием имени модели, времени выполнения и надежности каждого обнаруженного объекта.
    • Формат записи: Данные записываются с использованием f-строк, которые обеспечивают удобный способ форматирования строк в Python.

    Эти изменения гарантируют, что результаты работы каждой модели будут логироваться в текстовом файле вместе с информацией о времени и надёжности обнаружения.

  27. User

    для log_file используй разделитель ;

  28. Assistant

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

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_image_path):
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for model in yolo_models:
                results, elapsed_time = detect_objects(model, image_path)
    
                print(f"Processing with model {model.name}...")
                print(f"Time taken: {elapsed_time:.2f} seconds")
                for result in results:
                    boxes = result.boxes
                    for box in boxes:
                        class_id = box.cls[0]
                        confidence = box.conf[0]
                        
                        # Записываем в файл подробности с использованием точки с запятой как разделителя
                        f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f}\n")
    
                        print(f"Label: {model.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                model_name = model.name.replace(" ", "_")
                output_image_path = f"{output_base_path}_{model_name}.png"
                save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_image(image_path, yolo_models, output_base_path, log_file)
    

    Объяснение:

    • Использование ; как разделителя: Все строки, записываемые в файл журнала, используют ; как разделитель между полями (имя модели, время и надежность).
    • Другие изменения: Код остался без изменений, кроме строки записи в файл, чтобы сохранить структуру и функциональность.

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

  29. User

    Добавь ограничение чтобы модель искала и выводила QR CODE выше 0.8

  30. Assistant

    Чтобы добавить ограничение на вывод только тех объектов, например, QR-кодов, которые имеют уверенность выше 0.8, мы можем фильтровать результаты в цикле по детекторам перед тем, как записать их в файл журнала или отобразить. Вот как можно изменить код для добавления такого условия:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_image_path):
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_image(image_path, yolo_models, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for model in yolo_models:
                results, elapsed_time = detect_objects(model, image_path)
    
                print(f"Processing with model {model.name}...")
                print(f"Time taken: {elapsed_time:.2f} seconds")
                for result in results:
                    boxes = result.boxes
                    for box in boxes:
                        class_id = box.cls[0]
                        confidence = box.conf[0]
                        
                        # Проверяем, что обнаружено достаточной уверенностью и класс соответствует QR-коду
                        if confidence > 0.8 and int(class_id) == result.names.index('QR_CODE'):
                            f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f}\n")
                            print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                model_name = model.name.replace(" ", "_")
                output_image_path = f"{output_base_path}_{model_name}.png"
                save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Путь к изображению и базовый путь для сохранения
    image_path = "path_to_your_image.jpg"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_image(image_path, yolo_models, output_base_path, log_file)
    

    Объяснение:

    • Фильтрация по уверенности: Добавлен фильтр, чтобы обрабатывать только те результаты, где confidence > 0.8. Это гарантирует, что выводятся только уверенные детекции.
    • Фильтрация по классу: Я добавил условие int(class_id) == result.names.index('QR_CODE') как предполагаемый способ проверки на класс QR-кодов. Убедитесь, что 'QR_CODE' корректно совпадает с именем, используемым вашей моделью для класификации QR-кодов.

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

  31. User

    Добавь использования перебора файлов и вывод в log_file имя файла с заголовком files

  32. Assistant

    Чтобы обработать несколько изображений в одной папке и вывести результаты в журнал с указанием имени файла для каждого изображения, вы можете использовать модуль os для перебора всех файлов в заданной директории. Затем вы можете обрабатывать файлы по одному и записывать результаты в журнал.

    Вот как можно изменить код, чтобы добавить эту функциональность:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_image_path):
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    f.write(f"File: {filename}\n")  # Записываем имя файла в лог
                    
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_image_path = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директория с изображениями и базовый путь для сохранения выходных данных
    input_directory = "path_to_your_images_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_base_path, log_file)
    

    Объяснение:

    • Перебор файлов в директории: Используем os.listdir() для получения списка файлов в заданной директории и проверяем, что они имеют допустимые расширения изображений.
    • Запись имени файла в журнал: Перед обработкой каждого изображения записывается его имя в файл журнала.
    • Валидация изображений: Проверяется расширение каждого файла перед попыткой его обработки.
    • Обработка и запись результата: Для каждого файла и каждой модели выполняется детекция и результаты записываются в файл журнала, включая имя модели и уверенность.

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

  33. User

    имя файла должно быть указано тут f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f}\n")

  34. Assistant

    Конечно, давайте добавим имя файла в каждую запись результатов в журнале, чтобы каждая строка выглядела следующим образом: model_name;elapsed_time;confidence;filename.

    Вот как можно изменить код:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_image_path):
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_image_path = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_image_path)
    
    # Путь к весам
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директория с изображениями и базовый путь для сохранения выходных данных
    input_directory = "path_to_your_images_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_base_path, log_file)
    

    Объяснение:

    • Имя файла в журнале: Добавлено имя файла к записи о каждом предсказании в журнале, разделенное точкой с запятой, чтобы соответствовать формату model_name;elapsed_time;confidence;filename.
    • Единое условие: Условие фильтрации по уверенности (confidence > 0.8) остается, чтобы включать только релевантные детекции.

    Теперь, когда вы просматриваете файл журнала, каждая строка будет содержать информацию о модели, времени выполнения, надежности и имени файла изображения, на котором была выполнена детекция.

  35. User

    сохранение файлов cv2.imwrite(output_image_path, image) сделай в предопределенную папку

  36. Assistant

    Чтобы сохранять обработанные изображения в заранее заданную папку, необходимо убедиться, что эта папка существует, и указать её в пути при сохранении. Мы также будем использовать os.makedirs() с параметром exist_ok=True, чтобы создать эту папку, если она ещё не существует.

    Вот как вы можете изменить код для сохранения изображений в заданную папку:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_dir, output_filename):
        os.makedirs(output_dir, exist_ok=True)  # Убеждаемся, что директория существует
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        output_image_path = os.path.join(output_dir, output_filename)
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_dir, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_filename = f"{model_name}_{filename}"
                        save_results(image_path, results, output_dir, output_filename)
    
    # Пути к весам для моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директории для изображений и сохранения выходных изображений
    input_directory = "path_to_your_images_directory"
    output_directory = "path_to_your_output_directory"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_directory, log_file)
    

    Объяснение:

    • Создание директории: Используем os.makedirs(output_dir, exist_ok=True), чтобы гарантировать, что каталог существует, или создаём его, если это не так.
    • Предопределённая папка: Все выходные изображения сохраняются в указанной папке output_directory.
    • Имя выходного файла: Сохраняем файлы под названием, включающим имя модели и исходное имя файла.

    Теперь все обработанные изображения будут сохраняться в указанной папке, поддерживая организованную структуру выходных данных.

  37. User

    output_base_path тоже нужен

  38. Assistant

    Конечно, мы можем сохранить структуру с output_base_path, чтобы позволить вам задавать базовую часть имени файла и указывать директорию для сохранения результатов. Это позволит вам сохранять изображения с базовым именем, за которыми следуют имя модели и исходное имя файла.

    Вот код с поддержкой output_base_path:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_dir, output_filename):
        os.makedirs(output_dir, exist_ok=True)  # Убеждаемся, что директория существует
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        output_image_path = os.path.join(output_dir, output_filename)
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_dir, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_filename = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_dir, output_filename)
    
    # Пути к весам для моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директории для изображений и сохранения выходных изображений
    input_directory = "path_to_your_images_directory"
    output_directory = "path_to_your_output_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_directory, output_base_path, log_file)
    

    Объяснение:

    • output_base_path: Используется в имени файла, чтобы иметь возможность задать часть имени, т.е. "output_image_modelname_filename".
    • Предопределённая директория: Все выходные файлы сохраняются в указанной output_directory. Убедитесь, что путь к output_directory существует, или он будет создан автоматически.
    • Структура сохранения: Все результаты сохраняются организовано с дескриптивной номенклатурой для лёгкого доступа и понимания.

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

  39. User

    перед сохранением cv2.imwrite(output_image_path, image) нужно сжать картинку до HD разрешения

  40. Assistant

    Чтобы сжать изображение до разрешения HD (1280x720) перед его сохранением, мы можем воспользоваться функцией изменения размера cv2.resize(). При сохранении изображения в HD, важно сохранять пропорции исходного изображения, чтобы избежать искажений.

    Ниже приведён изменённый код, который сжимает изображение до HD разрешения перед сохранением:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_dir, output_filename):
        os.makedirs(output_dir, exist_ok=True)  # Убеждаемся, что директория существует
        image = cv2.imread(image_path)
        
        # Сжимаем изображение до HD разрешения (1280x720)
        target_width = 1280
        target_height = 720
        image = cv2.resize(image, (target_width, target_height), interpolation=cv2.INTER_AREA)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        output_image_path = os.path.join(output_dir, output_filename)
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_dir, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_filename = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_dir, output_filename)
    
    # Пути к весам для моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директории для изображений и сохранения выходных изображений
    input_directory = "path_to_your_images_directory"
    output_directory = "path_to_your_output_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_directory, output_base_path, log_file)
    

    Объяснение:

    • Изменение размера изображения: Используется функция cv2.resize() для изменения размера изображения до HD (1280x720). Применяется интерполяция ближайшего соседа для достижения желаемого размера.

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

  41. User

    менять разрешение нужно после cv2.rectangle cv2.putText

  42. Assistant

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

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

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def save_results(image_path, results, output_dir, output_filename, target_size=(1280, 720)):
        os.makedirs(output_dir, exist_ok=True)  # Обеспечиваем, что директория существует
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
    
        # Изменяем размер изображения до целевого разрешения HD (1280x720)
        image = cv2.resize(image, target_size, interpolation=cv2.INTER_AREA)
        
        output_image_path = os.path.join(output_dir, output_filename)
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_dir, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_filename = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_dir, output_filename)
    
    # Пути к весам для моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директории для изображений и сохранения выходных изображений
    input_directory = "path_to_your_images_directory"
    output_directory = "path_to_your_output_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_directory, output_base_path, log_file)
    

    Объяснение:

    • Сначала отрисовка, затем изменение размера: Прямоугольники и текст наносятся на изображение в исходном разрешении, а затем всё изображение уменьшается до HD.
    • Метод cv2.resize(): Используется с интерполяцией cv2.INTER_AREA, что подходит для уменьшения изображения. Это уменьшает размер изображения после отрисовки на нём всех графических элементов.

    Такая модификация позволяет добиться наилучшего визуального результата и соответствия разрешения без проблем с масштабированием деталей отрисовки.

  43. User

    при изменении разрешения на HD нужно учитывать в какой ориентации находится изображение

  44. Assistant

    Чтобы изменить разрешение изображения до HD (1280x720), учитывая его ориентацию, вам нужно определить, является оно портретным (больше по высоте) или альбомным (больше по ширине), и соответственно выбрать параметры размеров для изменения. В зависимости от ориентации, разрешение HD может быть либо 1280x720, либо 720x1280.

    Вот как можно изменить код с учётом ориентации изображения:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def resize_to_hd(image):
        height, width = image.shape[:2]
        # Определяем альбомная или портретная ориентация
        if width > height:
            new_dimensions = (1280, 720)  # Альбомная ориентация
        else:
            new_dimensions = (720, 1280)  # Портретная ориентация
    
        # Изменяем размер изображения, сохраняя пропорции
        return cv2.resize(image, new_dimensions, interpolation=cv2.INTER_AREA)
    
    def save_results(image_path, results, output_dir, output_filename):
        os.makedirs(output_dir, exist_ok=True)  # Обеспечиваем, что директория существует
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 
                            0.5, (0, 255, 0), 2)
        
        # Изменяем размер изображения с учётом ориентации
        image = resize_to_hd(image)
    
        output_image_path = os.path.join(output_dir, output_filename)
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_dir, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_filename = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_dir, output_filename)
    
    # Пути к весам для моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директории для изображений и сохранения выходных изображений
    input_directory = "path_to_your_images_directory"
    output_directory = "path_to_your_output_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_directory, output_base_path, log_file)
    

    Объяснение:

    • Определение ориентации изображения: Перед изменением разрешения функция resize_to_hd определяет, больше ли ширина высоты (альбомная) или меньше (портретная), и выбирает соответствующий размер.
    • Изменение размера после наложения графики: Нанесение прямоугольников и текста происходит перед изменением размера, чтобы сохранить точность позиции детекций.
  45. User

    а так же сохранять пропорции при изменении в HD

  46. Assistant

    Чтобы изменить размер изображения до разрешения HD (1280x720 или 720x1280) и при этом сохранить пропорции, необходимо учитывать соотношение сторон исходного изображения и добавить закрашенные поля (padding) по бокам или сверху/снизу, где это необходимо. Мы можем использовать OpenCV для заполнения изображений, если их соотношение сторон не точно соответствует целевым размерам.

    Вот как можно изменить код для изменения размера изображений с сохранением пропорций:

    from ultralytics import YOLO
    import cv2
    import os
    import time
    
    def load_yolo_model(weights_path):
        model = YOLO(weights_path)
        model.name = os.path.splitext(os.path.basename(weights_path))[0]
        return model
    
    def detect_objects(model, image_path):
        start_time = time.time()
        results = model(image_path)
        end_time = time.time()
        
        elapsed_time = end_time - start_time
        return results, elapsed_time
    
    def resize_to_hd_with_aspect_ratio(image):
        original_height, original_width = image.shape[:2]
        target_aspect_ratio = 1280 / 720
        img_aspect_ratio = original_width / original_height
        
        if img_aspect_ratio > target_aspect_ratio:
            # Изображение шире, чем целевое соотношение сторон
            new_width = 1280
            new_height = int(new_width / img_aspect_ratio)
        else:
            # Изображение выше, или точно то же соотношение, чем целевое
            new_height = 720
            new_width = int(new_height * img_aspect_ratio)
        
        # Изменяем размер изображения, сохраняя аспектное соотношение
        image = cv2.resize(image, (new_width, new_height), interpolation=cv2.INTER_AREA)
        
        # Вычисляем отступы
        top_pad = (720 - new_height) // 2
        bottom_pad = 720 - new_height - top_pad
        left_pad = (1280 - new_width) // 2
        right_pad = 1280 - new_width - left_pad
        
        # Добавляем черные поля, чтобы заполнить до 1280x720
        image_padded = cv2.copyMakeBorder(image, top_pad, bottom_pad, left_pad, right_pad, cv2.BORDER_CONSTANT, value=[0, 0, 0])
        
        return image_padded
    
    def save_results(image_path, results, output_dir, output_filename):
        os.makedirs(output_dir, exist_ok=True)  # Обеспечиваем, что директория существует
        image = cv2.imread(image_path)
        
        for result in results:
            boxes = result.boxes
            for box in boxes:
                x1, y1, x2, y2 = map(int, box.xyxy[0])
                confidence = box.conf[0]
                class_id = int(box.cls[0])
                label = f"{result.names[class_id]}: {confidence:.2f}"
    
                cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
                cv2.putText(image, label, (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        
        # Изменяем размер изображения с учетом пропорций
        image = resize_to_hd_with_aspect_ratio(image)
    
        output_image_path = os.path.join(output_dir, output_filename)
        cv2.imwrite(output_image_path, image)
        print(f"Results saved to {output_image_path}")
    
    def process_directory(input_dir, yolo_models, output_dir, output_base_path, log_file):
        with open(log_file, 'a') as f:  # Открытие файла в режиме добавления
            for filename in os.listdir(input_dir):
                image_path = os.path.join(input_dir, filename)
    
                # Проверяем, что файл является изображением
                if os.path.isfile(image_path) and filename.lower().endswith(('.png', '.jpg', '.jpeg')):
                    for model in yolo_models:
                        results, elapsed_time = detect_objects(model, image_path)
    
                        print(f"Processing {filename} with model {model.name}...")
                        print(f"Time taken: {elapsed_time:.2f} seconds")
                        for result in results:
                            boxes = result.boxes
                            for box in boxes:
                                class_id = box.cls[0]
                                confidence = box.conf[0]
    
                                # Проверяем уверенность и соответствие классу QR-кода
                                if confidence > 0.8:  # и класс соответствует QR-коду
                                    f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f};{filename}\n")
                                    print(f"Label: {result.names[int(class_id)]}, Confidence: {confidence:.2f}")
    
                        model_name = model.name.replace(" ", "_")
                        output_filename = f"{output_base_path}_{model_name}_{filename}"
                        save_results(image_path, results, output_dir, output_filename)
    
    # Пути к весам для моделей
    weights_path_1 = "path_to_your_first_model.pt"
    weights_path_2 = "path_to_your_second_model.pt"
    
    # Загрузка моделей
    yolo_models = [
        load_yolo_model(weights_path_1),
        load_yolo_model(weights_path_2)
    ]
    
    # Директории для изображений и сохранения выходных изображений
    input_directory = "path_to_your_images_directory"
    output_directory = "path_to_your_output_directory"
    output_base_path = "output_image"
    
    # Файл для сохранения логов
    log_file = "detection_results.txt"
    
    process_directory(input_directory, yolo_models, output_directory, output_base_path, log_file)
    

    Объяснение:

    • Сохранение пропорций: Функция resize_to_hd_with_aspect_ratio изменяет размер изображения с сохранением пропорций, добавляя черные поля для достижения целевого разрешения HD.
    • Рассчет пэддингов: Вычисляет пэддинги (top_pad, bottom_pad, left_pad, right_pad), чтобы разместить исходное изображение в центре и дополнить до необходимого размера, избегая искажений.

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