はじめる

Ultralytics YOLOでセグメンテーションオブジェクトを分離する方法

インスタンスセグメンテーションでは、検出された各オブジェクトについてピクセル単位で正確なマスクが生成されるため、画像から各オブジェクトを個別に切り出せます。このガイドでは、Predict ModeとOpenCVを使って、Ultralytics YOLOのセグメンテーション結果からオブジェクトを切り出し、背景を黒一色または透明にしてPNGとして保存する方法を説明します。



視聴: Ultralytics YOLO26でセグメント化されたオブジェクトを分離する方法 | Pythonチュートリアル | VisionAI 🚀

セグメンテーションオブジェクトを分離する理由#

画像から個々のオブジェクトを切り出すことで、さまざまな後続ワークフローを実現できます。

  • 商品写真、カタログ、クリエイティブ編集のための背景除去。
  • 検出結果から分類データセットを構築するためのオブジェクトごとのクロップ。
  • OCR、色分析、測定などの後続処理で周囲のシーンではなくオブジェクトだけを対象にするための対象を絞った処理。
  • オブジェクトを新しい背景に合成するための透明PNGエクスポート。

この手順は任意のUltralytics YOLOセグメンテーションモデルで使用でき、4つの段階で構成されます。推論を実行 → 各輪郭を抽出 → オブジェクトを分離 → 結果を保存。

セグメンテーション推論を実行する#

必要なライブラリをインストールし、YOLO26n-segなどのセグメンテーションモデルを読み込みます(マスクを生成するには-segサフィックスが必要です)。その後、入力画像に対して予測を実行します。

from ultralytics import YOLO

# セグメンテーションモデルを読み込む
model = YOLO("yolo26n-seg.pt")

# 入力画像で推論を実行する
results = model.predict(source="path/to/image.jpg")
入力画像がありませんか? YOLOは同梱のサンプル画像を使用します

sourceを指定せずにmodel.predict()を呼び出すと、Ultralyticsはパッケージに同梱されたサンプル画像(bus.jpgとzidane.jpg)を使用します。ワークフローをすばやくテストするのに便利です。

オブジェクトの輪郭を抽出する#

resultsの各要素は1枚の画像に対応し、結果を反復処理すると検出結果を1つずつ取得できます。各検出結果について、元の画像をコピーし、クラスラベルを読み取り、空の二値マスクにオブジェクトのマスク輪郭を描画します。このマスクの白い領域が、オブジェクトに属するピクセルを正確に示します。

このセクションと次のセクションのコードスニペットは、以下の検出ループの内部で実行します。コピーして実行できる完全なスクリプトは完全な例にあります。

Binary mask with the segmented object in white on a black background
from pathlib import Path

import cv2
import numpy as np

for r in results:
    img = np.copy(r.orig_img)
    img_name = Path(r.path).stem  # 入力画像のベース名

    # 画像内で検出された各オブジェクトを反復処理する
    for ci, c in enumerate(r):
        label = c.names[c.boxes.cls.tolist().pop()]  # クラス名

        # 二値マスクを作成し、オブジェクトの輪郭を描画する
        b_mask = np.zeros(img.shape[:2], np.uint8)
        contour = c.masks.xy[0].astype(np.int32).reshape(-1, 1, 2)
        cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED)
`c.masks.xy[0].astype(np.int32).reshape(-1, 1, 2)`は何をしますか?
  • c.masks.xy[0]は、この単一検出結果に含まれるオブジェクトの輪郭を、(x, y)の座標として返すマスクです。
  • .astype(np.int32)は、OpenCVのdrawContours()が受け付けないfloat32から点を変換します。
  • .reshape(-1, 1, 2)は、点を[N, 1, 2]レイアウトに整形します。このレイアウトをdrawContours()が想定しており、Nは輪郭点の数です。

インデックス-1を指定して[contour]を渡すと、指定した輪郭のすべての点が描画され、cv2.FILLEDによって囲まれたすべてのピクセルが白く塗りつぶされます。

オブジェクトを分離する#

二値マスクを用意したら、元の画像と組み合わせます。背景をどうするかに応じて、一般的な方法が2つあります。

分離方法を選択する

マスクを3チャンネルに変換し、オブジェクトと重なるピクセルだけを残します。輪郭の外側はすべて黒になります。

# 黒い背景でオブジェクトを分離する
mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
isolated = cv2.bitwise_and(mask3ch, img)
Full-size isolated object on a black background
黒い背景に表示した全体サイズの物体
バウンディングボックスに合わせてクロップする

画像全体ではなくオブジェクトの領域だけを残すには、検出結果のバウンディングボックスに合わせてスライスします。

# バウンディングボックスの座標
x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
# 分離した画像をオブジェクト領域に合わせてクロップする
iso_crop = isolated[y1:y2, x1:x2]
Isolated object cropped to its bounding box on a black background
バウンディングボックスに合わせて切り抜いた物体
元の背景を含めてクロップしたい場合は?

その機能は組み込まれています。save_crop=Trueをpredict()に渡すと、マスク処理を行わずにUltralyticsがバウンディングボックスのクロップを自動で保存します。

結果を保存する(任意)#

分離した各オブジェクトをどう扱うかは自由です。よくある次のステップは、後で使えるようにディスクに書き込むことです。

# Save the isolated object to file
cv2.imwrite(f"{img_name}_{label}-{ci}.png", isolated)

ここでimg_nameは入力画像のステム、labelはクラス名、ciは検出インデックスです。そのため、同じクラスの複数インスタンスにも一意のファイル名が付けられます。上の任意のクロップを適用した場合は、isolatedをiso_cropに置き換えてください。

完全な例#

以下のスクリプトでは、すべての手順を1つの実行可能なコードブロックにまとめています。デフォルトでは黒い背景を使用します。透明なPNGにするには、指定された1行をnp.dstack([img, b_mask])に変更してください。

from pathlib import Path

import cv2
import numpy as np

from ultralytics import YOLO

model = YOLO("yolo26n-seg.pt")
results = model.predict(source="path/to/image.jpg")

for r in results:
    img = np.copy(r.orig_img)
    img_name = Path(r.path).stem

    for ci, c in enumerate(r):
        label = c.names[c.boxes.cls.tolist().pop()]

        # Build a binary mask from the object contour
        b_mask = np.zeros(img.shape[:2], np.uint8)
        contour = c.masks.xy[0].astype(np.int32).reshape(-1, 1, 2)
        cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED)

        # Isolate the object (black background)
        mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
        isolated = cv2.bitwise_and(mask3ch, img)  # transparent PNG: isolated = np.dstack([img, b_mask])

        # Save or add your custom post-processing here
        cv2.imwrite(f"{img_name}_{label}-{ci}.png", isolated)

        # Optional: crop to the bounding box before saving
        # x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)
        # cv2.imwrite(f"{img_name}_{label}-{ci}.png", isolated[y1:y2, x1:x2])

繰り返し使用する場合は、ループ本体を関数にまとめると、多数の画像に対して呼び出せます。

結論#

これで、Ultralytics YOLOを使ってセグメンテーションオブジェクトを分離する一連の手順が完成しました。推論を実行し、各輪郭から二値マスクを作成してから、オブジェクトを黒または透明の背景上に抽出し、必要に応じてバウンディングボックスに合わせてクロップします。ワークフローを独自のクラスに合わせて調整するには、SegmentタスクとPredictモードのドキュメントをご覧ください。

よくある質問#

  • セグメンテーションモデルを読み込み、推論を実行し、各検出結果の輪郭から二値マスクを作成して、元の画像と組み合わせます。

    import cv2
    import numpy as np
    
    from ultralytics import YOLO
    
    model = YOLO("yolo26n-seg.pt")
    results = model.predict(source="path/to/your/image.jpg")
    
    img = np.copy(results[0].orig_img)
    b_mask = np.zeros(img.shape[:2], np.uint8)
    contour = results[0].masks.xy[0].astype(np.int32).reshape(-1, 1, 2)
    cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED)
    
    mask3ch = cv2.cvtColor(b_mask, cv2.COLOR_GRAY2BGR)
    isolated = cv2.bitwise_and(mask3ch, img)

    検出ごとのループ全体については、完全な例をご覧ください。

  • 主な方法は2つあります。黒い背景の場合は、マスクを3チャンネルに変換してcv2.bitwise_and()を使用します。透明な背景(PNGとして保存する場合)には、マスクを4番目のアルファチャンネルとして重ね、np.dstack([img, b_mask])を使用します。どちらの方法もオブジェクトを分離するで説明しています。

  • 検出結果からバウンディングボックスの座標を読み取り、分離した画像をスライスします。

    x1, y1, x2, y2 = results[0].boxes.xyxy[0].cpu().numpy().astype(np.int32)
    iso_crop = isolated[y1:y2, x1:x2]

    バウンディングボックスの結果について詳しくは、Predictモードのドキュメントをご覧ください。

  • Ultralytics YOLOは、高精度なマスクとバウンディングボックスを生成する、リアルタイムの高速なインスタンスセグメンテーションを提供します。また、推論結果から数行のOpenCVコードでオブジェクトを分離できる、シンプルなPython APIも備えています。

  • はい。predict()でsave_crop引数を使用すると、元の背景を含むバウンディングボックスの切り抜きを保存できます。

    results = model.predict(source="path/to/your/image.jpg", save_crop=True)

    詳しくは、予測モードの推論引数のセクションをご覧ください。

コメント16

質問したり、結果を共有したり、ほかの人をサポートしたりできます。

  1. AbdulGhofur23GitHub

    How can I extract a mask from a TIFF (Tag Image File Format) so that the mask's coordinates align with the projection of the TIFF image?

    1. Glenn JocherUltralytics

      To extract masks from a TIFF image while aligning the mask's coordinates with the image's projection, you can use the segmentation results from Ultralytics YOLO. Generate the mask using results.masks.xy for contour points and overlay it on the TIFF image. Ensure alignment by maintaining the original image dimensions during processing. For more, refer to the Isolating Segmentation Objects Guide. Let us know if you need further assistance!

      1
  2. vedhanayagan9626GitHub

    I used yolo v11n seg model , i got a segmented image as output with bounding boxes in those some of predictions are overlapped like a bounding box on two items as single so i try to remove a rectangle and associated segmentation from an image and add new rectangle by hold and drag functionality its looks likw working but i cant get optimized result. Is there any way to remove and add new bounding boxes after a segmentation result?

    1. Glenn JocherUltralytics

      @vedhanayagan9626 to address overlapping predictions, you can manually refine results by manipulating masks and bounding boxes post-inference. Use the mask and bounding box coordinates from results[0].masks and results[0].boxes to remove or modify specific predictions. For new bounding boxes, you might need to create and integrate them into your results structure manually. Refer to the Isolating Segmentation Objects guide for detailed steps. For optimized results, ensure adequate data quality and model tuning.

  3. SerhiiPostupaievGitHub

    Hello, can you please explain how the YOLOv8 performs upscaling? For example, my input images are 854x480, YOLOv8 scales them up to 864x512. How does it exactly performs upscaling? Does it use padding or some other approaches?

    1. Paula DerrengerUltralytics

      @SerhiiPostupaiev hello! In YOLOv8, images are scaled up or down to a specific model input size, optimally a square format (like 640x640) or a dimension supported by the model (such as 864x512 in your case). The upscaling for images that do not exactly match the input dimensions typically involves:

      1. Resizing the image to the closest dimension that maintains the aspect ratio.
      2. Padding the resized image to reach the required input size, ensuring that the aspect ratio is preserved.

      For instance, for an image of 854x480, YOLOv8 may:

      • Resize the image to fit the model's width of 864 while maintaining the aspect ratio, which adjusts the height accordingly.
      • Pad the height to the nearest model-supported dimension (like 512), adding pixel values (usually zeros) to the top and bottom or sides of the image to reach the required size.

      Here’s a rough example in Python using OpenCV for how padding might be handled:

      import cv2
      import numpy as np
      
      # Example image load
      image = cv2.imread('input.jpg')
      # Resizing the image
      resized_image = cv2.resize(image, (864, keep_aspect_ratio_height))  # Example variable for illustration
      
      # Padding the resized image
      top_padding = (512 - resized_image.shape[0]) // 2
      bottom_padding = 512 - resized_image.shape[0] - top_padding
      padded_image = cv2.copyMakeBorder(resized_image, top_padding, bottom_padding, 0, 0, cv2.BORDER_CONSTANT, value=[0, 0, 0])

      This ensures the entire image is used during prediction without distorting its original aspect ratio. 😊

  4. EnricoMendezGitHub

    Hello, I run this code example but it only display one object's mask, is it posible to join all the objects' masks in a single frame?

    1. Glenn JocherUltralytics

      Hey there! 😊 Absolutely, you can combine all the objects' masks into a single frame. Just modify the section where you're drawing the contours onto the mask. Instead of creating a new binary mask b_mask for each object, you initialize one common mask before iterating through the objects and draw every object's contour on this common mask. Here's a quick example to illustrate:

      # Initialize one common binary mask for all objects
      b_mask_all = np.zeros(img.shape[:2], np.uint8)
      
      for ci, c in enumerate(r):
          # Your contour extraction remains the same
          contour = c.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2)
          # Draw each contour onto the common mask
          cv2.drawContours(b_mask_all, [contour], -1, (255, 255, 255), cv2.FILLED)
      
      # After the loop, you can use `b_mask_all` which contains all objects' masks

      Just keep in mind, with b_mask_all, you'll have all the detected objects' masks on one mask. If the objects overlap in your image, their masks will also overlap in b_mask_all. Hope this helps! Let us know if you have more questions. 😊

  5. mariamg03GitHub

    hi is there a way I can apply the edits on the binary image then revert back to the original with the mask part edited?

    1. Paula DerrengerUltralytics

      Hey there! 👋 Yes, you can certainly make edits on a binary mask and then apply those changes back to the original image, essentially modifying only the parts that the mask covers. Here's a quick outline of how you could achieve this with an example focusing on segmentation tasks:

      1. After segmenting your image and obtaining the binary mask (let's say b_mask), you can perform any edits you like on this mask. For example, inverting the mask, dilating, or eroding.

      2. To apply the edited mask back to the original image (orig_img), you would use the mask to isolate the area of interest in the original image and then apply your edits.

      Here's a code snippet demonstrating this with a simple inversion edit:

      import cv2
      import numpy as np
      
      # Assuming 'b_mask' is your binary mask and 'orig_img' is your original image
      # Let's say you inverted the binary mask
      edited_mask = 255 - b_mask  # Inverting mask
      
      # Convert the single channel binary mask to a 3 channel mask to match the original image
      edited_mask_3ch = cv2.cvtColor(edited_mask, cv2.COLOR_GRAY2BGR)
      
      # Apply the edited mask back to the original image
      # This line performs bitwise-and operation to only keep parts of the image where the mask is white
      edited_image = cv2.bitwise_and(orig_img, edited_mask_3ch)
      
      # At this point, 'edited_image' contains the original image with edits applied to the segmented part

      This is a simplified example to show the concept. Depending on the edits you've made to b_mask, you might need to adjust how you apply edited_mask back to orig_img.

      Remember, after editing the mask, you can always revert it back to its original form if you've kept a copy before editing, or you can apply the inverse of your edits.

      I hope this helps! Let me know if you have more questions. Happy coding! 😊

  6. SafiislamianGitHub

    Hi sir, thanku for your response does load dataset will work or not. As the dataset is in yolo form where we have different folders and subfolders like train having images and labels etc

    On Wed, Mar 27, 2024, 7:03 AM Glenn Jocher @.***> wrote:

    Hey there! 👋 Glad to see you're interested in applying YOLOv8 for instance segmentation with a dataset from Roboflow. Below is a quick guide to help you get started with applying YOLOv8 for detection and then using masks for the dataset based on class. Step 1: Install Ultralytics YOLO

    First, ensure you have Ultralytics installed:

    pip install ultralytics

    Step 2: Load Your Model

    from ultralytics import YOLOmodel = YOLO('yolov8n-seg.pt') # Use yolov8n-seg.pt for segmentation models

    Step 3: Predict and Isolate Objects

    Now, for predicting and isolating objects based on their classes, you'll dive into the prediction results to access and manipulate the segmentation masks:

    results = model.predict(source='path/to/your/dataset')for result in results: for detection in result: class_name = detection.names[detection.boxes.cls.tolist().pop()] # Create a binary mask from detection binary_mask = np.zeros(result.orig_img.shape[:2], np.uint8) contour = detection.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2) cv2.drawContours(binary_mask, [contour], -1, (255, 255, 255), cv2.FILLED) # Example to save or further process the mask

    Note: Replace 'path/to/your/dataset' with the actual path to your images. Step 4: Saving or Processing the Masks

    You may wish to save each mask based on its class for processing later. You can modify the loop to save each binary mask to a file using cv2.imwrite() method.

    cv2.imwrite(f'{class_name}_mask.jpg', binary_mask)

    This will save each mask with its respective class name as part of the filename, allowing for easy organization by class.

    Hope this helps! 😊 Let us know if you need further assistance or have more questions. Happy coding!

    — Reply to this email directly, view it on GitHub https://github.com/orgs/ultralytics/discussions/9334#discussioncomment-8922405, or unsubscribe https://github.com/notifications/unsubscribe-auth/AUP75TG3RFWAL7YRMWDR66DY2ILE5AVCNFSM6AAAAABFJ334B2VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4DSMRSGQYDK . You are receiving this because you commented.Message ID: @.*** com>

    1. Paula DerrengerUltralytics(編集済み)

      Hi there! 😄

      Absolutely, loading a dataset structured in YOLO format (with separate folders for train/test images and labels) works well with YOLO26. You can specify the dataset structure in a YAML file and provide this file when initiating training or validation processes. Here's an example data.yaml file structure for your dataset:

      train: /path/to/dataset/train/images  #  path to images folder
      val: /path/to/dataset/val/images      #  path to validation images
      
      # Classes
      nc: 80  # number of classes
      names: ['class1', 'class2', ...]  # class names

      And here's how you might start training with your dataset:

      yolo detect train data=data.yaml model=yolo26n.pt

      Make sure to replace /path/to/dataset/train/images and /path/to/dataset/val/images with the actual paths to your dataset and similarly update the nc (number of classes) and names (class labels) accordingly.

      If you have any more questions or need further assistance, feel free to ask. Happy to help! 🚀

  7. SafiislamianGitHub

    There is a dataset on roboflow for instance segmentation, i want to apply first yolov8 and then masks for all the dataset arranged on the basis of their classes. please provide me details and code for that Thank you...

    1. Glenn JocherUltralytics(編集済み)

      Hey there! 👋 Glad to see you're interested in applying YOLO26 for instance segmentation with a dataset from Roboflow. Below is a quick guide to help you get started with applying YOLO26 for detection and then using masks for the dataset based on class.

      Step 1: Install Ultralytics YOLO

      First, ensure you have Ultralytics installed:

      pip install ultralytics
      Step 2: Load Your Model
      from ultralytics import YOLO
      model = YOLO('yolo26n-seg.pt')  # Use yolo26n-seg.pt for segmentation models
      Step 3: Predict and Isolate Objects

      Now, for predicting and isolating objects based on their classes, you'll dive into the prediction results to access and manipulate the segmentation masks:

      results = model.predict(source='path/to/your/dataset')
      for result in results:
          for detection in result:
              class_name = detection.names[detection.boxes.cls.tolist().pop()]
              # Create a binary mask from detection
              binary_mask = np.zeros(result.orig_img.shape[:2], np.uint8)
              contour = detection.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2)
              cv2.drawContours(binary_mask, [contour], -1, (255, 255, 255), cv2.FILLED)
              # Example to save or further process the mask

      Note: Replace 'path/to/your/dataset' with the actual path to your images.

      Step 4: Saving or Processing the Masks

      You may wish to save each mask based on its class for processing later. You can modify the loop to save each binary mask to a file using cv2.imwrite() method.

      cv2.imwrite(f'{class_name}_mask.jpg', binary_mask)

      This will save each mask with its respective class name as part of the filename, allowing for easy organization by class.

      Hope this helps! 😊 Let us know if you need further assistance or have more questions. Happy coding!