Save my local changes

code/RGBD/usplf_rgbd_data_preparation.py

@@ -0,0 +1,29 @@
+import os, glob
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+# adjust these paths
+color_dir = "path/to/your/color/images"
+depth_dir = "path/to/your/depth/images"
+out_dir   = "path/to/your/rgbd/images"
+
+os.makedirs(out_dir, exist_ok=True)
+
+print("Processing color and depth images...")
+for color_path in tqdm(glob.glob(os.path.join(color_dir, "*.png"))):
+    base = os.path.basename(color_path)
+    depth_path = os.path.join(depth_dir, base)
+    if not os.path.exists(depth_path):
+        continue
+
+    rgb = cv2.imread(color_path, cv2.IMREAD_UNCHANGED)     # H×W×3
+    depth = cv2.imread(depth_path, cv2.IMREAD_UNCHANGED)   # H×W   (raw depth)
+    depth = cv2.normalize(depth, None, 0, 255, cv2.NORM_MINMAX)
+    depth = depth.astype(np.uint8)
+
+    # merge to H×W×4 (B,G,R,Depth)
+    rgba = cv2.merge([ rgb[:,:,0], rgb[:,:,1], rgb[:,:,2], depth ])
+    cv2.imwrite(os.path.join(out_dir, base), rgba)
+
+print("RGBD data preparation completed.")

code/RGBD/yolo11_rgbd.yaml

@@ -0,0 +1,51 @@
+# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
+
+# Ultralytics YOLO11 object detection model with P3/8 - P5/32 outputs
+# Model docs: https://docs.ultralytics.com/models/yolo11
+# Task docs: https://docs.ultralytics.com/tasks/detect
+
+# Parameters
+nc: 5 # number of classes
+ch: 4 # number of input channels (4 for RGB-D, 3 for RGB)
+scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
+  # [depth, width, max_channels]
+  # n: [0.50, 0.25, 1024] # summary: 181 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
+  # s: [0.50, 0.50, 1024] # summary: 181 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
+  # m: [0.50, 1.00, 512] # summary: 231 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
+  l: [1.00, 1.00, 512] # summary: 357 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
+  # x: [1.00, 1.50, 512] # summary: 357 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
+
+# YOLO11n backbone
+backbone:
+  # [from, repeats, module, args]
+  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
+  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
+  - [-1, 2, C3k2, [256, False, 0.25]]
+  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
+  - [-1, 2, C3k2, [512, False, 0.25]]
+  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
+  - [-1, 2, C3k2, [512, True]]
+  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
+  - [-1, 2, C3k2, [1024, True]]
+  - [-1, 1, SPPF, [1024, 5]] # 9
+  - [-1, 2, C2PSA, [1024]] # 10
+
+# YOLO11n head
+head:
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
+  - [-1, 2, C3k2, [512, False]] # 13
+
+  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
+  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
+  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
+
+  - [-1, 1, Conv, [256, 3, 2]]
+  - [[-1, 13], 1, Concat, [1]] # cat head P4
+  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
+
+  - [-1, 1, Conv, [512, 3, 2]]
+  - [[-1, 10], 1, Concat, [1]] # cat head P5
+  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
+
+  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

code/RGBD/yolo_rgbd_model_inference.py

@@ -0,0 +1,96 @@
+
+import os
+import glob
+import cv2
+import numpy as np
+import torch
+from ultralytics import YOLO
+from tqdm import tqdm
+
+# ---- CONFIGURATION ----
+model_path = 'path/to/your/model/weights/best.pt'
+test_img_dir = 'path/to/your/rgbd/test/images'
+output_rgb_dir = 'outputs/rgb'
+output_depth_dir = 'outputs/depth'
+class_names = ['Feeding', 'Lateral_lying', 'Sitting', 'Standing', 'Sternal_lying']
+confidence_threshold = 0.65
+input_size = 640  # Model input size
+
+os.makedirs(output_rgb_dir, exist_ok=True)
+os.makedirs(output_depth_dir, exist_ok=True)
+
+# ---- Define consistent colors for each class ----
+COLORS = {
+    'Feeding':        (255, 0, 0),     # Blue
+    'Lateral_lying':  (0, 255, 0),     # Green
+    'Sitting':        (0, 0, 255),     # Red
+    'Standing':       (255, 255, 0),   # Cyan
+    'Sternal_lying':  (255, 0, 255)    # Magenta
+}
+
+# ---- LOAD MODEL ----
+model = YOLO(model_path).cuda().eval()
+
+# ---- INFERENCE LOOP ----
+image_paths = sorted(glob.glob(os.path.join(test_img_dir, '*.png')))
+
+for img_path in tqdm(image_paths, desc="Visualizing Predictions"):
+    base = os.path.splitext(os.path.basename(img_path))[0]
+
+    # Load original 4-channel image
+    img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+    if img is None or img.shape[-1] != 4:
+        print(f"Skipping {img_path}, invalid image format.")
+        continue
+
+    rgb = img[:, :, :3]
+    depth = img[:, :, 3]
+    orig_h, orig_w = rgb.shape[:2]
+
+    # Resize to model input size for inference
+    img_resized = cv2.resize(img, (input_size, input_size))
+    input_tensor = torch.from_numpy(img_resized).permute(2, 0, 1).float() / 255.0
+    input_tensor = input_tensor.unsqueeze(0).cuda()
+
+    # Inference
+    results = model.predict(input_tensor, imgsz=input_size, conf=confidence_threshold)[0]
+    boxes = results.boxes
+    classes = boxes.cls.cpu().numpy()
+    confidences = boxes.conf.cpu().numpy()
+    xyxy_resized = boxes.xyxy.cpu().numpy()
+
+
+    # Scale boxes back to original image size
+    scale_x = orig_w / input_size
+    scale_y = orig_h / input_size
+    xyxy_orig = np.copy(xyxy_resized)
+    xyxy_orig[:, [0, 2]] *= scale_x
+    xyxy_orig[:, [1, 3]] *= scale_y
+
+    # Normalize depth to uint8 for visualization
+    depth_norm = cv2.normalize(depth, None, 0, 255, cv2.NORM_MINMAX)
+    depth_uint8 = depth_norm.astype('uint8')
+
+    rgb_draw = rgb.copy()
+
+    # Apply a colormap for better visualization
+    depth_rgb = cv2.applyColorMap(depth_uint8, cv2.COLORMAP_VIRIDIS)  # Or COLORMAP_VIRIDIS, INFERNO, etc.
+    depth_draw = cv2.cvtColor(depth_rgb, cv2.COLOR_BGR2RGB)  # Convert BGR to RGB for matplotlib
+
+    # ---- Draw boxes on original-size RGB and Depth ----
+    for box, cls, conf in zip(xyxy_orig, classes, confidences):
+        x1, y1, x2, y2 = map(int, box)
+        label = f"{class_names[int(cls)]} {conf:.2f}"
+        color = COLORS.get(class_names[int(cls)], (255, 255, 255))  # Default to white
+
+        # RGB
+        cv2.rectangle(rgb_draw, (x1, y1), (x2, y2), color, 2)
+        cv2.putText(rgb_draw, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+
+        # Depth
+        cv2.rectangle(depth_draw, (x1, y1), (x2, y2), color, 2)
+        cv2.putText(depth_draw, label, (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
+
+    # Save images
+    cv2.imwrite(os.path.join(output_rgb_dir, f"{base}.png"), rgb_draw)
+    cv2.imwrite(os.path.join(output_depth_dir, f"{base}.png"), depth_draw)

code/RGBD/yolov11_usplf_rgbd.py

@@ -0,0 +1,79 @@
+from ultralytics import YOLO
+from ultralytics.data import build_dataloader
+from ultralytics.data.dataset import YOLODataset
+import torch
+import cv2
+
+class CustomYOLODataset(YOLODataset):
+    def __init__(self, *args, **kwargs):
+        kwargs["data"] = dict(kwargs.get("data", {}), channels=4)
+        super().__init__(*args, **kwargs)
+    
+    def __getitem__(self, index):
+        img_path = self.im_files[index]
+        img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+        assert img.shape[-1] == 4, f"Image {img_path} has {img.shape[-1]} channels"
+        return super().__getitem__(index)
+
+def build_dataloader_override(cfg, batch, img_size, stride, single_cls=False, hyp=None, augment=False, cache=False, pad=0.0, rect=False, rank=-1, workers=8, shuffle=False, data_info=None):
+    dataset = CustomYOLODataset(
+        data=data_info,
+        img_size=img_size,
+        batch_size=batch,
+        augment=augment,
+        hyp=hyp,
+        rect=rect,
+        cache=cache,
+        single_cls=single_cls,
+        stride=int(stride),
+        pad=pad,
+        rank=rank,
+    )
+    loader = torch.utils.data.DataLoader(
+        dataset=dataset,
+        batch_size=batch,
+        shuffle=shuffle,
+        num_workers=workers,
+        sampler=None,
+        pin_memory=True,
+        collate_fn=getattr(dataset, "collate_fn", None),
+    )
+    return loader
+
+build_dataloader.build_dataloader = build_dataloader_override
+
+# Initialize model
+model = YOLO("yolo11_rgbd.yaml")  # Ensure YAML has ch=4
+
+# ---- Load Pretrained Weights ----
+# pretrained = YOLO("yolo11l.pt").model.state_dict()
+pretrained = YOLO("yolo11n.pt").model.state_dict()
+model_state = model.model.state_dict()
+filtered_pretrained = {k: v for k, v in pretrained.items() if not k.startswith(("model.23", "model.0.conv"))}
+model_state.update(filtered_pretrained)
+
+with torch.no_grad():
+    rgb_weights = pretrained["model.0.conv.weight"][:, :3]
+    depth_weights = torch.randn(64, 1, 3, 3) * 0.1 # FOr Yolov11l model
+    # depth_weights = torch.randn(16, 1, 3, 3) * 0.1 # For Yolov11n model
+    model_state["model.0.conv.weight"] = torch.cat([rgb_weights, depth_weights], dim=1)
+
+model.model.load_state_dict(model_state, strict=False)
+
+# ---- Critical Warmup Fix ----
+def custom_warmup(self, imgsz=(1, 4, 640, 640)):  # Force 4-channel input
+    self.forward(torch.zeros(imgsz).to(self.device))
+
+model.model.warmup = custom_warmup.__get__(model.model)
+
+# Train
+model.train(
+    data="usplf_rgbd_dataset.yaml",
+    epochs=200,
+    imgsz=640,
+    batch=10,
+    device="0",
+    name="yolov11_rgbd_pretrained"
+)
+
+

code/color/usplf_dataset.yaml

@@ -0,0 +1,16 @@
+# pig_detect.yaml
+path: usplf
+train: train
+val: valid
+
+# Classes
+names:
+  0: Feeding
+  1: Lateral_lying
+  2: Sitting
+  3: Standing
+  4: Sternal_lying
+
+# 'feeding_pig', 'lateral_lying_pig', 'sitting_pig', 'standing_pig', 'sternal_lying_pig'
+
+#/home/dcs/workspaces/pigDetect/datasets/data/annotation/val

code/color/usplf_hvd_data_preparation.py

@@ -0,0 +1,42 @@
+import os, glob
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+# Adjust these paths
+color_dir = "path/to/your/color/images"
+depth_dir = "path/to/your/depth/images"
+out_dir = "path/to/your/hvd/images"  # Hue-Value-Depth
+
+os.makedirs(out_dir, exist_ok=True)
+
+print("Creating HVD images (Hue-Value-Depth)...")
+for color_path in tqdm(glob.glob(os.path.join(color_dir, "*.png"))):
+    base = os.path.basename(color_path)
+    depth_path = os.path.join(depth_dir, base)
+    if not os.path.exists(depth_path):
+        continue
+
+    # Read images
+    bgr = cv2.imread(color_path)  # BGR format
+    depth = cv2.imread(depth_path, cv2.IMREAD_UNCHANGED)
+    
+    # Convert to HSV and extract channels
+    hsv = cv2.cvtColor(bgr, cv2.COLOR_BGR2HSV)
+    h, s, v = cv2.split(hsv)
+    
+    # Normalize depth
+    if depth.dtype == np.uint16:
+        # Preserve relative depth relationships while scaling
+        depth = (depth / depth.max() * 255).astype(np.uint8)
+    else:
+        depth = cv2.normalize(depth, None, 0, 255, cv2.NORM_MINMAX)
+        depth = depth.astype(np.uint8)
+    
+    # Create HVD (Hue-Value-Depth) image
+    hvd = cv2.merge([h, v, depth])
+    
+    # Save result
+    cv2.imwrite(os.path.join(out_dir, base), hvd)
+
+print("HVD dataset preparation completed.")

code/color/usplf_hvd_dataset.yaml

@@ -0,0 +1,44 @@
+
+
+# # usplf_datasets.yaml (updated for RGB-D)
+# path: ./datasets/usplf  # Base path
+# train: 
+#   - path: train/images  # RGB images
+#     depth: train/depth  # Depth images
+#     labels: train/labels
+# val: 
+#   - path: valid/images
+#     depth: valid/depth
+#     labels: valid/labels
+
+# # RGB-D specific parameters
+# modality: rgbd  # Marks this as RGB-D dataset
+# depth_normalization:  # Depth-specific settings
+#   min: 0.0    # Minimum depth in meters
+#   max: 2.0    # Maximum depth in meters
+#   scaling: 255.0  # Scale factor
+
+# # Class names
+# names: 
+#   0: Feeding
+#   1: Lateral_lying
+#   2: Sitting
+#   3: Standing
+#   4: Sternal_lying
+
+# usplf_dataset.yaml
+path: datasets/usplf/hvd  # Root directory
+train: train  # Path to training images (relative to 'path')
+val: valid      # Path to validation images
+test: test    # Path to test images (optional)
+
+# Number of input channels (R, G, B, D)
+nc: 5  # 4-channel RGB-D input
+
+# Class names (replace with your pig postures)
+names: 
+  0: Feeding
+  1: Lateral_lying
+  2: Sitting
+  3: Standing
+  4: Sternal_lying

code/color/yolo_model_evaluation.py

@@ -0,0 +1,136 @@
+import os
+import glob
+import numpy as np
+import matplotlib
+matplotlib.use('TkAgg')  # interactive plotting
+import matplotlib.pyplot as plt
+from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, classification_report
+from ultralytics import YOLO
+from tqdm import tqdm
+import cv2
+from collections import defaultdict
+
+
+# ---- CONFIGURATION ----
+# model_path = 'datasets/usplf/model_weight/color_model/best.pt'
+# model_path = 'runs/usplf_depth_color/train/weights/best.pt'
+# test_img_dir = 'datasets/usplf/depth_color/test/images'
+# test_lbl_dir = 'datasets/usplf/depth_color/test/labels'
+
+model_path = 'path/to/your/model/weights/best.pt'
+test_img_dir = 'path/to/your/test/images'
+test_lbl_dir = 'path/to/your/test/labels'
+class_names = ['Feeding', 'Lateral_lying', 'Sitting', 'Standing', 'Sternal_lying']
+n_classes = len(class_names)
+iou_threshold = 0.5
+confidence_threshold = 0.65
+
+# ---- LOAD MODEL ----
+model = YOLO(model_path)
+
+# ---- IOU FUNCTION ----
+def compute_iou(box1, box2):
+    xa1, ya1 = box1[0] - box1[2]/2, box1[1] - box1[3]/2
+    xa2, ya2 = box1[0] + box1[2]/2, box1[1] + box1[3]/2
+    xb1, yb1 = box2[0] - box2[2]/2, box2[1] - box2[3]/2
+    xb2, yb2 = box2[0] + box2[2]/2, box2[1] + box2[3]/2
+
+    inter_x1, inter_y1 = max(xa1, xb1), max(ya1, yb1)
+    inter_x2, inter_y2 = min(xa2, xb2), min(ya2, yb2)
+    inter_area = max(0, inter_x2 - inter_x1) * max(0, inter_y2 - inter_y1)
+    box1_area = (xa2 - xa1) * (ya2 - ya1)
+    box2_area = (xb2 - xb1) * (yb2 - yb1)
+    union_area = box1_area + box2_area - inter_area
+    return inter_area / union_area if union_area > 0 else 0
+
+# Count ground truth instances and missed predictions (FN)
+gt_counts = defaultdict(int)
+missed_counts = defaultdict(int)
+
+# ---- COLLECT PRED/GT PAIRS ----
+y_true_all, y_pred_all = [], []
+
+# grab both jpg and png
+image_paths = sorted(glob.glob(os.path.join(test_img_dir, '*.jpg')) +
+                     glob.glob(os.path.join(test_img_dir, '*.png')))
+print(f"Found {len(image_paths)} test images")
+
+total_gt_inst = 0
+for img_path in tqdm(image_paths, desc="Evaluating"):
+    img = cv2.imread(img_path)
+    h, w = img.shape[:2]
+    base = os.path.splitext(os.path.basename(img_path))[0]
+
+    # load GT boxes
+    gt_boxes = []
+    gt_file = os.path.join(test_lbl_dir, base + '.txt')
+    if os.path.exists(gt_file):
+        with open(gt_file) as f:
+            for line in f:
+                parts = list(map(float, line.split()))
+                # [cls, xc, yc, w, h] normalized
+                gt_boxes.append(parts)
+                total_gt_inst += 1
+    gt_used = [False]*len(gt_boxes)
+
+    # predict
+    res = model(img, conf=confidence_threshold, verbose=False)[0]
+    dets = res.boxes
+    preds = []
+    if dets is not None and len(dets.cls):
+        for cls, xywh in zip(dets.cls.cpu().numpy(), dets.xywhn.cpu().numpy()):
+            preds.append((int(cls), xywh))
+
+    # match preds → GT
+    for pred_cls, pred_box in preds:
+        matched = False
+        for i,(gt_cls,*gt_box) in enumerate(gt_boxes):
+            if gt_used[i]: continue
+            iou = compute_iou(pred_box, gt_box)
+            if iou >= iou_threshold:
+                y_true_all.append(int(gt_cls))
+                y_pred_all.append(pred_cls)
+                gt_used[i] = True
+                matched = True
+                # print("GT: ",gt_cls, "Prd: ",pred_cls)
+                break
+        if not matched:
+            # a prediction with no GT match → FP
+            y_true_all.append(n_classes)   # use index=n_classes for “background”
+            y_pred_all.append(pred_cls)
+
+    # any GT not matched → FN
+    for used, (gt_cls, *_) in zip(gt_used, gt_boxes):
+        if not used:
+            y_true_all.append(int(gt_cls))
+            y_pred_all.append(n_classes)   # “predicted” background
+
+# ---- BUILD & SHOW METRICS ----
+# we have n_classes real + 1 background class → ignore background in report
+labels = list(range(n_classes))
+# filter out any true/pred == n_classes (we don't pass them to classification_report)
+# mask = [ (t in labels and p in labels) for t,p in zip(y_true_all, y_pred_all) ]
+# y_true = [y_true_all[i] for i,m in enumerate(mask) if m]
+# y_pred = [y_pred_all[i] for i,m in enumerate(mask) if m]
+y_true = y_true_all
+y_pred = y_pred_all
+
+print("Total GT instances: ",total_gt_inst)
+# confusion matrix
+cm = confusion_matrix(y_true, y_pred, labels=labels) # without normalization
+# cm = confusion_matrix(y_true, y_pred, labels=labels, normalize='true') # normalize by row
+disp = ConfusionMatrixDisplay(cm, display_labels=class_names) 
+disp.plot(xticks_rotation=45, cmap='Blues')
+plt.title("Confusion Matrix")
+plt.tight_layout()
+plt.savefig("path/to/your/confusion_matrix.png")
+plt.show()
+
+# classification report
+print(classification_report(
+    y_true, y_pred,
+    labels=labels,
+    target_names=class_names,
+    digits=3,
+    zero_division=0
+))

code/color/yolo_model_usplf_inference.py

@@ -0,0 +1,83 @@
+import os
+import glob
+import cv2
+import torch
+from ultralytics import YOLO
+from tqdm import tqdm
+
+# ---- CONFIGURATION ----
+# model_path = 'runs/usplf_color_yolo11n/train/weights/best.pt'
+# test_img_dir = 'datasets/usplf/test/images'
+model_path = 'path/to/your/model/weights/best.pt'
+test_img_dir = 'path/to/your/test/images'
+class_names = ['Feeding', 'Lateral_lying', 'Sitting', 'Standing', 'Sternal_lying']
+output_rgb_dir = 'path/to/your/output/test_frames'
+confidence_threshold = 0.45
+
+os.makedirs(output_rgb_dir, exist_ok=True)
+
+# ---- Define consistent colors for each class ----
+COLORS = {
+    'Feeding':        (255, 0, 0),     # Blue
+    'Lateral_lying':  (0, 255, 0),     # Green
+    'Sitting':        (128, 128, 128), # Grey
+    'Standing':       (255, 255, 0),   # Yellow
+    'Sternal_lying':  (255, 0, 255)    # Magenta
+}
+
+os.makedirs(output_rgb_dir, exist_ok=True)
+
+# ---- LOAD MODEL ----
+model = YOLO(model_path).cuda().eval()
+
+# ---- INFERENCE LOOP ----
+image_paths = sorted(glob.glob(os.path.join(test_img_dir, '*.png')))  # Ensure consistent sorting
+
+for img_path in tqdm(image_paths, desc="Visualizing Predictions"):
+    base = os.path.splitext(os.path.basename(img_path))[0]
+    
+    # Load original image
+    img = cv2.imread(img_path)
+    if img is None:
+        print(f"Warning: Could not read image {img_path}")
+        continue
+
+    # Inference - use the numpy array directly
+    results = model(img, conf=confidence_threshold, verbose=False)[0]  # Process single image
+    boxes = results.boxes
+
+    # Create a copy for drawing detections
+    rgb_draw = img.copy()
+
+    # Process detections if any exist
+    if boxes is not None and len(boxes):
+        # Convert results to numpy arrays
+        classes = boxes.cls.cpu().numpy()
+        confidences = boxes.conf.cpu().numpy()
+        xyxy_coords = boxes.xyxy.cpu().numpy()
+
+        # Draw each detection
+        for box, cls_id, conf in zip(xyxy_coords, classes, confidences):
+            x1, y1, x2, y2 = map(int, box)  # Convert coordinates to integers
+            label = class_names[int(cls_id)]
+            color = COLORS.get(label, (255, 255, 255))  # Default to white if not found
+            
+            # Draw bounding box
+            cv2.rectangle(rgb_draw, (x1, y1), (x2, y2), color, 2)
+            
+            # Prepare label text
+            text = f"{label} {conf:.2f}"
+            
+            # Calculate text position (avoid top overflow)
+            y_text = max(y1 - 5, 15)
+            
+            # Draw label background
+            (text_width, text_height), _ = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)
+            cv2.rectangle(rgb_draw, (x1, y1), (x1 + text_width, y1 - text_height - 5), color, -1)
+            
+            # Draw text
+            cv2.putText(rgb_draw, text, (x1, y_text), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+
+    # Save output
+    cv2.imwrite(os.path.join(output_rgb_dir, f"{base}.png"), rgb_draw)

code/color/yolov11_usplf.py

@@ -0,0 +1,25 @@
+from ultralytics import YOLO
+
+# Load a model
+model = YOLO("yolo11l.pt")
+
+# Train the model
+train_results = model.train(
+    # data="usplf_hvd_dataset.yaml",  # path to dataset YAML for usplf depth_color dataset
+    data="usplf_dataset.yaml",  # path to dataset YAML for usplf color dataset
+    epochs=150,  # number of training epochs
+    imgsz=640,  # training image size
+    device="0",  # device to run on, i.e. device=0 or device=0,1,2,3 or device=cpu
+    batch=8,  # batch size
+)
+
+# Evaluate model performance on the validation set
+metrics = model.val()
+
+# Perform object detection on an image
+# results = model("p1c1_20250108_085727.png")
+results = model("datasets/usplf/hvd/test/images/p1c1_20250108_085727.png")
+results[0].show()
+
+# Export the model to ONNX format
+path = model.export(format="onnx")  # return path to exported model

model_weight/Depth/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e6e3ba32605b7c68104f7cf2dc573a40b2b5bfc5a936240179745b1f6c0f2af2
+size 5461395

model_weight/HVD/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28736c85f144eb6e84e55c6a1eb1aaeb61b26eecec43cc58e5f5512dcec45102
+size 51189202

model_weight/RGB/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac0424695ade7f4946c8248f4cfdd3f78ef37afe8650039f9894d5c71fde1f85
+size 152952970

model_weight/RGBD/best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ab2932581d4e29ed1daac770990efd5ca721ab490e5258492ef494542a55fdc
+size 51190617