Как изолировать объекты сегментации с помощью Ultralytics YOLO#

@cordonballas thank you for your positive feedback! We're glad the segmentation isolation guide was helpful. If you have any further questions, feel free to ask—the YOLO community and our team are here to help. 😊

For continued support, check our Segment Task documentation and Predict Mode guide.

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!

@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.

@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. 😊

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. 😊

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! 😊

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! 🚀

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!