есть библиотека лучше zxing для распознания QR CODE
- User
есть библиотека лучше zxing для распознания QR CODE
- Assistant
Да, на сегодняшний день существует несколько библиотек, которые могут предложить альтернативы ZXing для распознавания QR-кодов. Вот некоторые из них:
-
zbar: Это C-библиотека, которая также поддерживает сканирование QR-кодов. Она известна своей скоростью и поддерживает множество языков через обертки.
-
QR Code Detector API (определяется вместе с OpenCV): OpenCV - мощная библиотека для компьютерного зрения, и в последних версиях она имеет встроенные функции для обнаружения и декодирования QR-кодов.
-
Dynamsoft Barcode Reader: Это коммерческая библиотека, которая поддерживает широкий спектр форматов штрих-кодов и QR-кодов и предлагает высокую скорость и точность.
-
Google ML Kit: Это мобильный SDK от Google, который включает возможности распознавания QR-кодов и штрих-кодов. Он оптимизирован для мобильных устройств.
-
Barcode4j: Это другая Java-библиотека, которая поддерживает генерацию и распознавание штрих-кодов и QR-кодов.
Каждая из этих библиотек имеет свои особенности, преимущества и недостатки, поэтому выбор зависит от ваших конкретных требований и условий использования.
-
- User
что из списка ZXing , zbar, OpenCV качественнее определяет QR CODE
- Assistant
Качество определения QR-кодов может зависеть от множества факторов, включая используемые алгоритмы, условия освещения, угол наклона, размер кода и настройку камеры. Тем не менее, вот несколько общих замечаний о каждой из этих библиотек:
-
ZXing:
- Преимущества: Хорошо зарекомендовавшая себя библиотека, широко используется, поддерживает множество форматов штрих-кодов, кросс-платформенная.
- Недостатки: Иногда может быть медленнее или менее точно определять QR-коды в сложных условиях по сравнению с другими библиотеками.
-
ZBar:
- Преимущества: Известна своей высокой скоростью и эффективностью, особенно при работе с видео-потоками. Легко интегрируется на разных платформах через обертки.
- Недостатки: Интерфейс может быть менее интуитивным, чем у некоторых других библиотек.
-
OpenCV:
- Преимущества: Очень мощная и гибкая библиотека для компьютерного зрения, поддерживает широкий спектр функций, включая распознавание QR-кодов. Хорошо работает в сложных условиях при правильной настройке.
- Недостатки: Может иметь более сложную настройку для задач, связанных с распознаванием QR-кодов, по сравнению с специализированными библиотеками.
Если вам нужна простота и стабильность для большинства простых случаев, ZXing может быть хорошим выбором. Если скорость и работа с видео являются приоритетами, стоит рассмотреть ZBar. Если же у вас сложный проект, где требуется больше контроля и возможностей компьютерного зрения, OpenCV может быть идеальным выбором, особенно если вы готовы потратить время на его освоение и настройку.
-
- User
Приведи пример как распознать QR CODE на библиотеке OpenCV
- 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)Объяснение кода:
- Импорт библиотек: Основная библиотека — это OpenCV, которая используется для обработки изображений.
- Загрузка изображения: Используется
cv2.imread()для загрузки изображения. - Создание QRCodeDetector: Объект QRCodeDetector создается для обнаружения и декодирования QR-кодов.
- Обнаружение и декодирование: Метод
detectAndDecode()обнаруживает и декодирует QR-код. Он возвращает текст, извлеченный из QR-кода, и массив координат углов QR-кода. - Отображение результатов: Если QR-код найден, результат печатается, и углы QR-кода соединяются линиями на изображении для наглядности.
Убедитесь, что на вашем компьютере установлена соответствующая версия OpenCV (
opencv-python), которая поддерживает эту функциональность. Если OpenCV еще не установлен, его можно установить командойpip install opencv-python. - User
если входное изображение с QR CODE плохого качества, как обработать и улучшить для того чтобы библиотека с уверенностью его распознала
- Assistant
Обработка изображений с плохим качеством, содержащих QR-коды, может сделать процесс распознавания более надежным. Вот несколько подходов, которые могут помочь улучшить качество входного изображения с QR-кодом перед попыткой его распознавания с помощью OpenCV:
-
Грейскейл преобразование:
- Преобразование изображения в градации серого может сократить количество данных и облегчить последующую обработку.
-
Бинаризация:
- Используйте адаптивную бинаризацию (например, метод Оцу или адаптивный порог) для улучшения контрастности QR-кода относительно фона.
-
Увеличение четкости (sharpness enhancement):
- Используйте фильтры, такие как лапласиан для увеличения четкости изображения.
-
Морфологическая обработка:
- Применение морфологических операций, таких как открытие или закрытие, может помочь уменьшить шум или заполнить пробелы в структурах.
-
Удаление шума:
- Применение фильтров, таких как гауссово размытие, медианный фильтр, для удаления мелкого шума в изображении.
-
Увеличение резкости (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)Объяснение:
- Размытие и бинаризация помогают уменьшить шум и четко выделить код на фоне.
- Морфологическая обработка помогает удалить мелкие шумы и улучшить структуру изображения.
- Изображение также можно дополнительно масштабировать или обрезать, если это необходимо, для улучшения результата.
Вы можете регулировать параметры фильтров и порогов, исходя из конкретных проблем или артефактов, встречающихся на ваших изображениях. Экспериментирование с различными техническими приемами может помочь добиться наилучших результатов.
-
- User
как загрузить несколько моделей YOLO в одном коде
- Assistant
Загрузка и использование нескольких моделей YOLO в одном коде — это полезный прием, когда у вас есть разные модели, обученные для конкретных задач, и вы хотите использовать их вместе для анализа изображений. Это может быть полезно, например, для различных задач распознавания объектов на одном изображении. Ниже приведен пример того, как можно реализовать такой подход на Python с использованием OpenCV и YOLO.
Шаги:
- Загрузите веса и конфигурации моделей YOLO.
- Создайте сети (net) для каждой модели.
- Обработайте изображение и примените каждую модель для детекции объектов.
Вот пример кода, который показывает основные шаги:
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. - User
модели в одном файле с расширением pt
- 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на вашем компьютере. - Загрузка моделей: Функция
- User
а если используется YOLOv8
- Assistant
Для работы с моделями YOLOv8, разработанными командой Ultralytics, вы можете воспользоваться их библиотекой, которая обеспечивает простую API для предсказаний. Установка и запуск различных моделей YOLOv8 немного отличается, но она также весьма удобна.
Вот как вы можете использовать несколько моделей YOLOv8, каждая из которых сохранена в формате
.pt, в одном скрипте:-
Убедитесь, что библиотека
ultralyticsустановлена. Вы можете сделать это, выполнив команду:pip install ultralytics -
Далее вы можете загрузить и использовать модели транспорта различным образом.
Вот пример кода:
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 в одном скрипте и обрабатывать изображения для каждой модели последовательно, выводя и отображая соответствующие результаты.
-
- User
Ошибка, исправь results.show() ^^^^^^^^^^^^ AttributeError: 'list' object has no attribute 'show'
- 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.
- Визуализация результатов: Метод
- User
в место показа сделай сохранение в файл png
- 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 вместо отображения их на экране.
- Запись изображения: Мы используем
- User
в имени файла output_image добавь имя модели
- 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на реальные имена ваших моделей. Это делает выходные файлы более управляемыми и читаемыми. - Имена моделей: Мы добавляем аргумент
- User
имя модели возьми из weights_path_1 и weights_path_2 до .pt
- 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содержат понятные для вас названия моделей, чтобы результаты были легко читаемыми. - Извлечение имени модели: Мы используем
- User
добавь вывод времени работы каждой модели
- 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(): Время выполнения предсказания для каждой модели измеряется с помощью захвата временной метки до и после выполнения предсказания. Разница этих временных меток дает нам продолжительность выполнения. - Вывод времени: После выполнения предсказания код выводит время, которое потребовалось для обработки изображения данной моделью.
Таким образом, вы получаете представление о производительности каждой модели на вашем изображении, что может быть полезно для оптимизации и выбора подходящей модели для ваших нужд.
- Использование
- User
добавь сохранение результата в тестовый файл, в формате model, Time taken, Confidence
- 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.
Эти изменения гарантируют, что результаты работы каждой модели будут логироваться в текстовом файле вместе с информацией о времени и надёжности обнаружения.
- Открытие файла: Используется
- User
для log_file используй разделитель ;
- 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)Объяснение:
- Использование
;как разделителя: Все строки, записываемые в файл журнала, используют;как разделитель между полями (имя модели, время и надежность). - Другие изменения: Код остался без изменений, кроме строки записи в файл, чтобы сохранить структуру и функциональность.
Теперь данные в журнале будут записаны с использованием точки с запятой в качестве разделителя, что может быть полезно для удобного парсинга при последующем анализе.
- Использование
- User
Добавь ограничение чтобы модель искала и выводила QR CODE выше 0.8
- 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'соответственно. - Фильтрация по уверенности: Добавлен фильтр, чтобы обрабатывать только те результаты, где
- User
Добавь использования перебора файлов и вывод в log_file имя файла с заголовком files
- 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()для получения списка файлов в заданной директории и проверяем, что они имеют допустимые расширения изображений. - Запись имени файла в журнал: Перед обработкой каждого изображения записывается его имя в файл журнала.
- Валидация изображений: Проверяется расширение каждого файла перед попыткой его обработки.
- Обработка и запись результата: Для каждого файла и каждой модели выполняется детекция и результаты записываются в файл журнала, включая имя модели и уверенность.
Таким образом, код становится более универсальным и позволяет обрабатывать большое количество изображений в одной операции.
- Перебор файлов в директории: Используем
- User
имя файла должно быть указано тут f.write(f"{model.name};{elapsed_time:.2f};{confidence:.2f}\n")
- 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) остается, чтобы включать только релевантные детекции.
Теперь, когда вы просматриваете файл журнала, каждая строка будет содержать информацию о модели, времени выполнения, надежности и имени файла изображения, на котором была выполнена детекция.
- Имя файла в журнале: Добавлено имя файла к записи о каждом предсказании в журнале, разделенное точкой с запятой, чтобы соответствовать формату
- User
сохранение файлов cv2.imwrite(output_image_path, image) сделай в предопределенную папку
- 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. - Имя выходного файла: Сохраняем файлы под названием, включающим имя модели и исходное имя файла.
Теперь все обработанные изображения будут сохраняться в указанной папке, поддерживая организованную структуру выходных данных.
- Создание директории: Используем
- User
output_base_path тоже нужен
- 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существует, или он будет создан автоматически. - Структура сохранения: Все результаты сохраняются организовано с дескриптивной номенклатурой для лёгкого доступа и понимания.
Эта структура позволяет сохранять все выходные данные в одном месте, а также обеспечивает уникальные и различимые имена для каждого выходного файла.
- User
перед сохранением cv2.imwrite(output_image_path, image) нужно сжать картинку до HD разрешения
- 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). Применяется интерполяция ближайшего соседа для достижения желаемого размера.
Этот подход предполагает, что вы хотите просто растянуть изображение до указанного размера. Если важно сохранить пропорции, можно применить метод изменения с удержанием аспектного соотношения.
- Изменение размера изображения: Используется функция
- User
менять разрешение нужно после cv2.rectangle cv2.putText
- 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, что подходит для уменьшения изображения. Это уменьшает размер изображения после отрисовки на нём всех графических элементов.
Такая модификация позволяет добиться наилучшего визуального результата и соответствия разрешения без проблем с масштабированием деталей отрисовки.
- User
при изменении разрешения на HD нужно учитывать в какой ориентации находится изображение
- 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определяет, больше ли ширина высоты (альбомная) или меньше (портретная), и выбирает соответствующий размер. - Изменение размера после наложения графики: Нанесение прямоугольников и текста происходит перед изменением размера, чтобы сохранить точность позиции детекций.
- Определение ориентации изображения: Перед изменением разрешения функция
- User
а так же сохранять пропорции при изменении в HD
- 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, избегая качественных потерь и наносимых искажений.
- Сохранение пропорций: Функция