Começar

Recorte de objetos com Ultralytics YOLO26

O que é o recorte de objetos?#

O recorte de objetos com o Ultralytics YOLO26 consiste em isolar e extrair objetos detectados específicos de uma imagem ou vídeo. O YOLO26 localiza cada objeto com uma caixa delimitadora, e o recortador salva essa região como uma imagem separada para análise ou processamento posterior.



Assista: Recorte de objetos usando Ultralytics YOLO

Vantagens do recorte de objetos#

  • Análise direcionada: o YOLO26 permite recortar objetos específicos, possibilitando o exame ou o processamento detalhado de itens individuais em uma cena.
  • Redução do volume de dados: ao extrair apenas os objetos relevantes, o recorte de objetos reduz o tamanho dos dados, tornando mais eficientes o armazenamento, a transmissão e as tarefas computacionais posteriores.
  • Maior precisão: a precisão da detecção de objetos do YOLO26 produz recortes bem ajustados que preservam os detalhes visuais necessários para análises posteriores.

Elementos visuais#

Bagagens no aeroporto
Recorte de malas na esteira de bagagens do aeroporto com Ultralytics YOLO26
Recorte de malas na esteira de bagagens do aeroporto com Ultralytics YOLO26

Recorte objetos com YOLO26#

Passe seu vídeo para a solução ObjectCropper: ela detecta objetos em cada frame e salva cada detecção como uma imagem separada. Restrinja o recorte a classes específicos, aumente conf para manter apenas detecções confiáveis e defina crop_dir para escolher onde os recortes serão gravados.

Recorte de objetos com Ultralytics YOLO
# Crop the objects
yolo solutions crop

# Pass a source video
yolo solutions crop source="path/to/video.mp4"

# Crop specific classes
yolo solutions crop classes="[0, 2]"

Argumentos de ObjectCropper#

Aqui está uma tabela com os argumentos de ObjectCropper:

ArgumentoTipoPadrãoDescrição
modelstrNoneCaminho para um arquivo de modelo Ultralytics YOLO.
crop_dirstr'cropped-detections'Nome do diretório para armazenar deteções recortadas.
verboseboolTrueAtiva o registro por quadro da solução, com o formato da entrada, as contagens por classe e a velocidade de processamento. A chamada de rastreamento em si é sempre silenciosa.

ObjectCropper executa predict em vez de track, portanto oferece suporte aos seguintes parâmetros de inferência, exceto tracker:

ArgumentoTipoPadrãoDescrição
trackerstr'tracktrack.yaml'Especifica o algoritmo de rastreamento a utilizar. Opções integradas: botsort.yaml, bytetrack.yaml, ocsort.yaml, deepocsort.yaml, fasttrack.yaml, tracktrack.yaml.
conffloat0.25Define o limiar de confiança das deteções; valores mais baixos permitem rastrear mais objetos, mas podem incluir falsos positivos.
ioufloat0.5Define o limiar de interseção sobre união (IoU) para filtrar deteções sobrepostas.
classeslistNoneFiltra os resultados pelo índice da classe. Por exemplo, classes=[0, 2, 3] rastreia apenas as classes especificadas.
devicestrNoneEspecifica o dispositivo para a inferência (por exemplo, cpu, cuda:0 ou 0). Permite escolher entre CPU, uma GPU específica ou outros dispositivos de computação para executar o modelo.
imgszint or tuple640Tamanho da imagem de destino para a inferência: um número inteiro para uma imagem quadrada ou um par (height, width). As dimensões são ajustadas ao stride do modelo.
max_detint300Número máximo de deteções mantidas por fotograma antes do rastreamento, limitando os objetos que uma solução processa em cenas densas.
quantizeint or strNonePrecisão de inferência: 16 (FP16) ou 32/unset (FP32) para modelos PyTorch e TorchScript fora da CPU; os outros formatos usam a precisão selecionada pelo artefato e pelo ambiente de execução. Substitui o argumento obsoleto half.

Perguntas frequentes#

  • O recorte de objetos com o Ultralytics YOLO26 consiste em isolar e extrair objetos específicos de uma imagem ou vídeo com base nos recursos de detecção do YOLO26. Esse processo permite uma análise direcionada e reduz o volume de dados, usando o YOLO26 para identificar objetos com precisão e recortá-los de acordo.

  • O Ultralytics YOLO26 combina detecção precisa, inferência rápida e uma API simples, então o recorte exige apenas algumas linhas de código e permite uma análise direcionada. O YOLO26 também exporta para formatos como OpenVINO e TensorRT para implantações em tempo real em diversos hardwares.

  • Ao usar o Ultralytics YOLO26 para recortar apenas objetos relevantes das suas imagens ou vídeos, você pode reduzir significativamente o tamanho dos dados, tornando o armazenamento e o processamento mais eficientes. Use um modelo pré-treinado ou treine um modelo para detectar os objetos de que precisa e, em seguida, recorte e salve apenas essas regiões.

  • Sim, o Ultralytics YOLO26 pode processar fluxos de vídeo em tempo real para detectar e recortar objetos dinamicamente. Sua inferência rápida é adequada para aplicações em tempo real, como vigilância, análise esportiva e sistemas de inspeção automatizada.

  • O Ultralytics YOLO26 é otimizado para ambientes com CPU e GPU, mas, para obter o melhor desempenho, especialmente em inferências em tempo real ou de alto volume, recomenda-se uma GPU dedicada (por exemplo, uma NVIDIA RTX ou uma GPU de centro de dados). Para a implantação em dispositivos leves, considere usar o CoreML para iOS ou o LiteRT para Android.

Comentários15

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. NOSPAA21GitHub

    Can i use it so as to train a model especially for printed circuit board defect detection to find defects in certain regions of a pcb?Would this be helpful?

    1. RizwanMunawarGitHub

      @NOSPAA21 Yes, you can train the Ultralytics YOLO11 model on the circuit board defect detection dataset by following the training documentation. Once the model is trained, you can use the object-cropping solution to crop the different defects that the model detects.

    1. Glenn JocherUltralytics

      @AdityaJaiswal99 thank you for your question! If you're looking to avoid capturing the same objects multiple times within a frame, you can leverage the Non-Maximum Suppression (NMS) feature of YOLOv8. NMS helps in eliminating redundant bounding boxes by keeping only the highest confidence detections and discarding others that overlap significantly.

      Here's a brief example of how you can adjust the iou threshold to refine your detections and reduce duplicates:

      from ultralytics import YOLO
      
      # Load the model
      model = YOLO("yolov8n.pt")
      
      # Set the IoU threshold to a lower value to reduce overlapping detections
      results = model.predict("path/to/your/image_or_video", iou=0.5)
      
      # Process the results as needed
      for result in results:
          boxes = result.boxes.xyxy.cpu().tolist()
          clss = result.boxes.cls.cpu().tolist()
          # Further processing...

      In this example, setting the iou parameter to a lower value (e.g., 0.5) helps in reducing the number of overlapping boxes, thus minimizing the chances of capturing the same object multiple times.

      For a more comprehensive guide on object cropping and additional tips, please visit our Object Cropping Guide.

      If you encounter any issues or have further questions, feel free to provide a reproducible example, and ensure you are using the latest version of the packages. This will help us assist you more effectively. 😊

      Happy coding!

    1. Paula DerrengerUltralytics

      @AdityaJaiswal99 hi there!

      To change the frame height, width, and FPS of a video using OpenCV, you can set these properties directly on the cv2.VideoCapture and cv2.VideoWriter objects. Below is an example of how you can achieve this:

      import cv2
      
      # Load the video
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      # Set the desired frame width, height, and FPS
      frame_width = 640  # Set your desired width
      frame_height = 480  # Set your desired height
      fps = 30  # Set your desired FPS
      
      # Create a VideoWriter object to save the modified video
      video_writer = cv2.VideoWriter("modified_video.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (frame_width, frame_height))
      
      while cap.isOpened():
          success, frame = cap.read()
          if not success:
              break
      
          # Resize the frame to the desired dimensions
          resized_frame = cv2.resize(frame, (frame_width, frame_height))
      
          # Write the resized frame to the output video
          video_writer.write(resized_frame)
      
          # Display the frame (optional)
          cv2.imshow("Resized Video", resized_frame)
          if cv2.waitKey(1) & 0xFF == ord("q"):
              break
      
      # Release resources
      cap.release()
      video_writer.release()
      cv2.destroyAllWindows()

      This script reads a video, resizes each frame to the specified width and height, and writes the modified frames to a new video file with the desired FPS.

      For more detailed information on object cropping using YOLOv8, you can refer to our Object Cropping Guide.

      Feel free to reach out if you have any more questions! 😊

      1
    1. Glenn JocherUltralytics(editado)

      Hello! To crop only people from your video, filter the detections by class. In COCO-trained models 'person' is class 0, so the simplest way is the classes argument of predict:

      import os
      
      import cv2
      
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      
      cap = cv2.VideoCapture("path/to/video/file.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      crop_dir_name = "ultralytics_crop"
      os.makedirs(crop_dir_name, exist_ok=True)
      
      idx = 0
      while cap.isOpened():
          success, im0 = cap.read()
          if not success:
              break
      
          results = model.predict(im0, classes=[0])  # 0 = 'person' in COCO
          boxes = results[0].boxes.xyxy.cpu().tolist()
      
          for box in boxes:
              idx += 1
              crop_obj = im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])]
              cv2.imwrite(os.path.join(crop_dir_name, f"person_{idx}.png"), crop_obj)
      
      cap.release()
      cv2.destroyAllWindows()

      This will crop and save images only for detected persons. Note that model.names is a dictionary mapping class IDs to names, so to look up an ID by name use next(k for k, v in model.names.items() if v == "person"). Adjust according to your specific classes and needs! 👍

    2. Glenn JocherUltralytics(editado)

      Hello! We're really glad you found the materials helpful! If you ever need to crop specific classes, such as 'people', filter the detections by class ID. Here's a quick example:

      import cv2
      
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")  # Load your model
      person_class_id = next(k for k, v in model.names.items() if v == "person")  # model.names maps class ID -> name
      
      cap = cv2.VideoCapture("path/to/video.mp4")
      assert cap.isOpened(), "Error reading video file"
      
      while cap.isOpened():
          ret, frame = cap.read()
          if not ret:
              break
          results = model.predict(frame, classes=[person_class_id])  # only 'person' detections
          boxes = results[0].boxes.xyxy.cpu().tolist()
      
          for idx, box in enumerate(boxes):
              x1, y1, x2, y2 = map(int, box[:4])
              crop_img = frame[y1:y2, x1:x2]
              cv2.imwrite(f"cropped_person_{idx}.jpg", crop_img)

      Feel free to replace 'person' with any class you're interested in, and make sure the class name matches what's defined in your model's class names. Let us know if you need further assistance! 🚀

      1
    3. umairrkhnGitHub

      Hey Glenn, I am getting this error using your implementation:

      person_class_id = model.names.index('person') # Ensure 'person' is in the model's class names ^^^^^^^^^^^^^^^^^ AttributeError: 'dict' object has no attribute 'index'

    4. Glenn JocherUltralytics(editado)

      Hey there!

      It looks like you're trying to use the .index() method on a dictionary, which isn't supported. model.names is a dictionary mapping class IDs to class names, not a list. Here's how to find the ID for a class name:

      model = YOLO("yolo26n.pt")
      person_class_id = next(k for k, v in model.names.items() if v == "person")

      For COCO-trained models this is simply 0. If the issue persists, could you share more of your code context? That might help diagnose the issue better. 😊

    5. Glenn JocherUltralytics(editado)

      Hey there! It looks like you're trying to use the index() method on a dictionary, which isn't supported. model.names is a dictionary mapping class IDs to class names, so you need to look up the ID by name:

      person_class_id = next(k for k, v in model.names.items() if v == "person")

      Make sure that 'person' is indeed the name of the class you're interested in. Let me know if this helps or if you need further assistance! 😊

    6. zakirhGitHub

      To those who are facing issue on finding person class:

      person_class_id = None for class_id, class_name in model.names.items(): if class_name =='person': person_class_id = class_id break

      if person_class_id is None: print("The 'person' class was not found.") else: print(f"'person' class ID: {person_class_id}")

    7. Glenn JocherUltralytics(editado)

      @zakirh thank you for sharing this helpful approach to finding the class ID for 'person.' For others who might encounter similar issues, note that model.names is a dictionary mapping class IDs to class names, so finding an ID by name requires searching the values. If any further clarification is needed, feel free to ask!

      1