FBK-TeV/FishGrade

---

Vision-Guided Robotic System for Automatic Fish Quality Grading and Packaging

This dataset (recorded with a Realsense D456 camera), associated with our work accepted in the IEEE/CAA Journal of Automatica Sinica, includes images and corresponding instance segmentation annotations (in YOLO format) of hake fish steaks on an industrial conveyor belt. It also provides BAG files for two quality grades of fish steaks (A and B), where A-grade steaks are generally larger. The paper details our use of YOLOv8 instance segmentation (check HERE how to train and validate the model) to isolate the fish steaks and the subsequent measurement of their size using the depth data from the BAG files.

🤗 [Paper] Coming soon ...

📽️ Demo Video

Dataset Structure

🗂️ BAG files & trained segmentation model:

Please first read the associated paper to understand the proposed pipeline.

The BAG files for A and B grades, as well as the weights of the trained segmentation model (best.pt and last.pt), can be found [HERE]..

The segmentation model is designed to segment fish samples. The BAG files are intended for testing purposes. For example, you could use the provided model weights to segment the RGB images within the BAG files and then measure their size based on the depth data.

For clarity, a simplified code snippet for measuring steaks' (metric) perimeter is provided below. You can repurpose this for your specific task:

import pyrealsense2 as rs
import numpy as np
import cv2
import copy
import time
import os
import torch
from ultralytics import YOLO
from random import randint
import math
import matplotlib.pyplot as plt

class ARC:
    def __init__(self):
        bag = r'Class_A_austral.bag' # path of the bag file
        self.start_frame = 0 # start from the this frame to allow the sensor to adjust
        # ROI coordinates are determined from the depth images (checked visually and fixed)
        self.x1_roi, self.x2_roi = 250, 1280
        self.y1_roi, self.y2_roi = 0, 470    
        self.delta = 5 # to discard steaks occluded along the borders of the image
        self.area_tresh = 80 
        self.bag = bag
        self.device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

        # load and run model
        self.my_model = YOLO('./weights/last.pt') # path of the bag file

        self.pipeline = rs.pipeline()
        config = rs.config()
        config.enable_device_from_file(bag, False)
        config.enable_all_streams()

        profile = self.pipeline.start(config)
        device = profile.get_device()
        playback = device.as_playback()
        playback.set_real_time(False)        

        ####################  POSTPROCESSING  ########################################
        self.fill_filter = rs.hole_filling_filter()
        ##############################################################################

    def video(self):
        align_to = rs.stream.color
        align = rs.align(align_to)

        t_init_wait_for_frames = time.time()
        for i in range(self.start_frame):
            self.pipeline.wait_for_frames()
        t_end_wait_for_frames = time.time()
        i = self.start_frame
        while True:            
            t_init_all = time.time()
            frames = self.pipeline.wait_for_frames()
            aligned_frames = align.process(frames)
            color_frame = aligned_frames.get_color_frame()
            depth_frame = aligned_frames.get_depth_frame()
            self.color_intrin = color_frame.profile.as_video_stream_profile().intrinsics

            # postprocessing, hole filling of depth noise
            depth_frame = self.fill_filter.process(depth_frame).as_depth_frame()

            # if raw depth is used
            self.depth_frame = depth_frame

            # Convert color_frame to numpy array to render image in opencv
            color_image = np.asanyarray(color_frame.get_data())
            rgb_image = cv2.cvtColor(color_image, cv2.COLOR_BGR2RGB)
           
            results = list(self.my_model(rgb_image, conf=0.7, retina_masks=True, verbose=False, device=self.device))
            result = results[0] # The results list may have multiple values, one for each detected object. Because in this example we have only one object in each image, we take the first list item.

            if result.masks == None: # Proceed only if there are detected steaks
                print('---------> Frame {}: No steaks detected'.format(i))
                i += 1
            else: 
                print('---------> Frame {} >> Processing {} steak(s)'.format(i, len(result.masks)))
                masks = result.masks.data
                masks = masks.detach().cpu()
                # resize masks to image size (yolov8 outputs padded masks on top and bottom stripes that are larger in width wrt input image)             
                padding_width = int((masks.shape[1] - rgb_image.shape[0])/2)
                masks = masks[:, padding_width:masks.shape[1]-padding_width, :]

                # filter out the masks that lie at the predefined (above) ROI (e.g., occluded fish steaks, because they cannot be graded if not whole) 
                id_del = []
                for id_, msk in enumerate(masks):
                    x_coord = np.nonzero(msk)[:, 1]
                    y_coord = np.nonzero(msk)[:, 0]
                    # ROI
                    x_del1 = x_coord <= self.x1_roi + self.delta
                    x_del2 = x_coord >= self.x2_roi - self.delta
                    if True in x_del1 or True in x_del2:
                        id_del.append(id_)
                        del x_del1, x_del2   
                id_keep = list(range(masks.shape[0]))
                id_keep = [item for item in id_keep if item not in id_del]
                masks = masks[id_keep]

                # calculate the perimeter of each object ############################################################################################ PERIMETER
                polygons = result.masks.xyn
                # scale the yolo format polygon coordinates by image width and height
                for pol in polygons:
                    for point_id in range(len(pol)):
                        pol[point_id][0] *= rgb_image.shape[1] 
                        pol[point_id][1] *= rgb_image.shape[0]
                polygons = [polygons[item] for item in id_keep]        
                t_init_perimeter = time.time()
                perimeters = [0]*len(polygons)
                for p in range(len(polygons)): # the polygon (mask) id
                    step = 5  # dist measurement step between polygon points
                    for point_id in range(0, len(polygons[p])-step, step):
                        x1 = round(polygons[p][point_id][0])
                        y1 = round(polygons[p][point_id][1])
                        x2 = round(polygons[p][point_id + step][0])
                        y2 = round(polygons[p][point_id + step][1])

                        # calculate_distance between polygon points
                        dist = self.calculate_distance(x1, y1, x2, y2)
                        # print('> x1, y1, x2, y2:  {},  {},  {},  {}'.format(x1, y1, x2, y2), '--- distance between the 2 points: {0:.10} cm'.format(dist))

                        # # visualise the points on the image
                        # image_points = copy.deepcopy(rgb_image)
                        # image_points = cv2.circle(image_points, (x1,y1), radius=3, color=(0, 0, 255), thickness=-1)
                        # image_points = cv2.circle(image_points, (x2,y2), radius=3, color=(0, 255, 0), thickness=-1)
                        # image_points = cv2.putText(image_points, 'Distance {} cm'.format(dist), org = (50, 50) , fontFace = cv2.FONT_HERSHEY_SIMPLEX , fontScale = 1, color = (255, 0, 0) , thickness = 2)
                        # cv2.imshow('image_points' + str(id_), image_points)
                        # cv2.waitKey(0)
                        # cv2.destroyAllWindows()  

                        # accumulate the distance in cm
                        perimeters[p] += dist
                        perimeters[p] = round(perimeters[p], 2)
                        del dist, x1, y1, x2, y2
                i += 1

    def calculate_distance(self, x1, y1, x2, y2):
        color_intrin = self.color_intrin
        udist = self.depth_frame.get_distance(x1, y1)
        vdist = self.depth_frame.get_distance(x2, y2)
        # print udist, vdist
        point1 = rs.rs2_deproject_pixel_to_point(color_intrin, [x1, y1], udist)
        point2 = rs.rs2_deproject_pixel_to_point(color_intrin, [x2, y2], vdist)

        dist = math.sqrt(math.pow(point1[0] - point2[0], 2) + math.pow(point1[1] - point2[1],2) + math.pow(point1[2] - point2[2], 2))
        return round(dist*100, 2)   # multiply by 100 to convert m to cm

if __name__ == '__main__':
    ARC().video()

🗂️ Data Instances

🏷️ Annotation Format

Note that the annotations follow the YOLO instance segmentation format.

Please refer to this page for more info.

🧪 How to read and display examples

from datasets import load_dataset
import matplotlib.pyplot as plt
import random
import numpy as np

def show_example(dataset):
    example = dataset[random.randint(0, len(dataset) - 1)]
    image = example["image"].convert("RGB")
    annotations = example["annotations"]
    width, height = image.size

    fig, ax = plt.subplots(1)
    ax.imshow(image)

    num_instances = len(annotations)
    colors = plt.cm.get_cmap('viridis', num_instances)

    if annotations:
        for i, annotation in enumerate(annotations):
            class_id = annotation["class_id"]
            segmentation = annotation.get("segmentation")
            if segmentation and len(segmentation) > 0:
                polygon_norm = segmentation[0]
                if polygon_norm:
                    polygon_abs = np.array([(p[0] * width, p[1] * height) for p in polygon_norm])
                    x, y = polygon_abs[:, 0], polygon_abs[:, 1]
                    color = colors(i)
                    ax.fill(x, y, color=color, alpha=0.5)

    plt.title(f"Example with {len(annotations)} instances")
    plt.axis('off')
    plt.show()

if __name__ == "__main__":
    dataset_name = "MohamedTEV/FishGrade"
    try:
        fish_dataset = load_dataset(dataset_name, split="train")
        print(fish_dataset)
        show_example(fish_dataset)
    except Exception as e:
        print(f"Error loading or displaying the dataset: {e}")
        print(f"Make sure the dataset '{dataset_name}' exists and is public, or you are logged in if it's private.")

🙏 Acknowledgement

This work is supported by European Union’s Horizon Europe research and innovation programme under grant agreement No 101092043, project AGILEHAND (Smart Grading, Handling and Packaging Solutions for Soft and Deformable Products in Agile and Reconfigurable Lines).

🤝 Partners

📖 Citation

Coming soon ... ```