Repository: opencv
Issue: Realsense Camera: Cannot open camera and Camera out of index
Labels: bug,category: videoio(camera)

### System Information

OpenCV python version: 4.8.1.78 
Operating System / Platform: Ubuntu 20.04
Python version: 3.8.10 with ROS Noetic
Camera model: Intel Realsense D435

### Detailed description

Hi, I'm using Realsense Camera and Yolov5 segmentation. 
When I run this **code** on Windows, it **works** normally
```
import argparse
import os
import platform
import sys
from pathlib import Path
from PIL import ImageDraw, ImageFont
import torch
import numpy as np
import time
import pyrealsense2 as rs
import math
import threading

FILE = Path(__file__).resolve()
ROOT = FILE.parents[1]  # YOLOv5 root directory
if str(ROOT) not in sys.path:
    sys.path.append(str(ROOT))  # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd()))  # relative


from models.common import DetectMultiBackend
from utils.dataloaders import IMG_FORMATS, VID_FORMATS, LoadImages, LoadScreenshots, LoadStreams
from utils.general import (LOGGER, Profile, check_file, check_img_size, check_imshow, check_requirements, colorstr, cv2,
                           increment_path, non_max_suppression, print_args, scale_boxes, scale_segments,
                           strip_optimizer)
from utils.plots import Annotator, colors, save_one_box
from utils.segment.general import masks2segments, process_mask, process_mask_native
from utils.torch_utils import select_device, smart_inference_mode
from math import atan2, cos, sin, sqrt, pi, asin, acos


cfg = rs.config() #ok
cfg.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30) #ok
cfg.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30) #ok

pipe = rs.pipeline()
profile = pipe.start(cfg)

align_to = rs.stream.color
align = rs.align(align_to)

intr = profile.get_stream(rs.stream.color).as_video_stream_profile().get_intrinsics() #ok


def find_plane(points):
    c = np.mean(points, axis=0)       # Calculate average of the array
    r0 = points - c                   # Calculate centroid
    u, s, v = np.linalg.svd(r0)       # Perform SVD
    nv = v[-1, :]                     # Set normal vector for the last column of v
    ds = np.dot(points, nv)           # Calculate distance between each point
    param = np.r_[nv, -np.mean(ds)]
    return param

def drawAxis(img, p_, q_, colour, scale):
    p = list(p_)
    q = list(q_)

    angle = atan2(p[1] - q[1], p[0] - q[0])  # angle in radians
    hypotenuse = sqrt((p[1] - q[1]) * (p[1] - q[1]) + (p[0] - q[0]) * (p[0] - q[0]))
    
    # Here we lengthen the arrow by a factor of scale
    q[0] = p[0] - scale * hypotenuse * cos(angle)
    q[1] = p[1] - scale * hypotenuse * sin(angle)
    cv2.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv2.LINE_AA)
    
    # create the arrow hooks
    p[0] = q[0] + 9 * cos(angle + pi / 4)
    p[1] = q[1] + 9 * sin(angle + pi / 4)
    
    cv2.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv2.LINE_AA)
    p[0] = q[0] + 9 * cos(angle - pi / 4)
    p[1] = q[1] + 9 * sin(angle - pi / 4)
    cv2.line(img, (int(p[0]), int(p[1])), (int(q[0]), int(q[1])), colour, 1, cv2.LINE_AA)

def get_frame_stream():
    # Wait for a coherent pair of frames: depth and color
    frames = pipe.wait_for_frames()
    aligned_frames = align.process(frames)
    depth_frame = aligned_frames.get_depth_frame()
    color_frame = aligned_frames.get_color_frame()
    depth_frame.get_height()

    if not depth_frame or not color_frame:
        # If there is no frame, probably camera not connected, return False
        print(
            "Error, impossible to get the frame, make sure that the Intel Realsense camera is correctly connected")
        return None, None

        # Apply filter to fill the Holes in the depth image
    color_intrin = color_frame.profile.as_video_stream_profile().intrinsics

    spatial = rs.spatial_filter()
    spatial.set_option(rs.option.holes_fill, 3)
    filtered_depth = spatial.process(depth_frame)

    hole_filling = rs.hole_filling_filter()
    filled_depth = hole_filling.process(filtered_depth)

    # Create colormap to show the depth of the Objects
    colorizer = rs.colorizer()
    depth_colormap = np.asanyarray(colorizer.colorize(filled_depth).get_data())

    # Convert images to numpy arrays
    # distance = depth_frame.get_distance(int(50),int(50))
    # print("distance", distance)
    depth_image = np.asanyarray(filled_depth.get_data())
    color_image = np.asanyarray(color_frame.get_data())

    # cv2.imshow("Colormap", depth_colormap)
    # cv2.imshow("depth img", depth_image)

    return True, frames, color_image, depth_image, color_frame, depth_frame, color_intrin

@smart_inference_mode()
@torch.no_grad()
def run(
    # weights=ROOT / 'yolo5s-seg.pt',  # model.pt path(s)
    weights=ROOT /'yolo5s-seg.pt',
    source=ROOT / 'data/images',  # file/dir/URL/glob/screen/0(webcam)
    data=ROOT / 'data/coco128-seg.yaml',  # dataset.yaml path
    imgsz=(640, 640),  # inference size (height, width) #OG@(640, 640)
    conf_thres=0.79,  # confidence threshold
    iou_thres=0.66,  # NMS IOU threshold #OG@0.45
    max_det=10,  # maximum detections per image
    device='',  # cuda device, i.e. 0 or 0,1,2,3 or cpu
    view_img=False,  # show results
    save_txt=False,  # save results to *.txt
    save_conf=False,  # save confidences in --save-txt labels
    save_crop=False,  # save cropped prediction boxes
    nosave=False,  # do not save images/videos
    classes=None,  # filter by class: --class 0, or --class 0 2 3
    agnostic_nms=True,  # class-agnostic NMS  #overlap 2 or more labels on 1 object
    augment=False,  # augmented inference  
    visualize=False,  # visualize features
    update=False,  # update all models
    project=ROOT / 'runs/predict-seg',  # save results to project/name
    name='exp',  # save results to project/name
    exist_ok=False,  # existing project/name ok, do not increment
    line_thickness=1,  # bounding box thickness (pixels)
    hide_labels=False,  # hide labels
    hide_conf=False,  # hide confidences
    half=False,  # use FP16 half-precision inference
    dnn=False,  # use OpenCV DNN for ONNX inference
    vid_stride=1,  # video frame-rate stride
    retina_masks=False,
    WHITE = (225, 255, 255), # color for displaying #BGR
    RED = (0, 0, 255), # color for displaying #BGR
    GREEN = (0, 255, 0), # color for displaying #BGR
    TEAL = (255, 255, 0), # color for displaying #BGR
    PINK = (255, 0, 255) # color for displaying #BGR

):
    source = str(source)
    is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
    is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://'))
    webcam = source.isnumeric() or source.endswith('.streams') or (is_url and not is_file)
    if is_url and is_file:
        source = check_file(source)  # download

    # Directories
    save_dir = increment_path(Path(project) / name, exist_ok=exist_ok)  # increment run
    (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True)  # make dir

    # Load model
    device = select_device(device)
    model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
    stride, names, pt = model.stride, model.names, model.pt
    imgsz = check_img_size(imgsz, s=stride)  # check image size

    # Dataloader
    bs = 1  # batch_size
    view_img = check_imshow(warn=True)
    #cap = cv2.VideoCapture(1)
    #frame_img = cap.read()
    dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
    bs = len(dataset)
    vid_path, vid_writer = [None] * bs, [None] * bs
    get_frame_stream()


    # # Dataloader
    # # bs = 1  # batch_size
    # if webcam:
    #     view_img = check_imshow(warn=True)
    #     dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
    #     bs = len(dataset)
    # # elif screenshot:
    # #     dataset = LoadScreenshots(source, img_size=imgsz, stride=stride, auto=pt)
    # else:
    #     dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
    #     bs = 1  # batch_size
    # vid_path, vid_writer = [None] * bs, [None] * bs

    # Run inference
    model.warmup(imgsz=(1 if pt else bs, 3, *imgsz))  # warmup
    seen, windows, dt = 0, [], (Profile(), Profile(), Profile())
    for path, im, im0s, vid_cap, s in dataset:
        
        num_threads = threading.active_count()
        
        with dt[0]:
            frame_img = vid_cap
            im = torch.from_numpy(im).to(model.device)
            im = im.half() if model.fp16 else im.float()  # uint8 to fp16/32
            imnew = im.half() if model.fp16 else im.int()  # uint8 to fp16/32
            im /= 255  # 0 - 255 to 0.0 - 1.0
            if len(im.shape) == 3:
                im = im[None]  # expand for batch dim

        # Inference
        with dt[1]:
            visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False
            pred, proto = model(im, augment=augment, visualize=visualize)[:2]

        # NMS
        with dt[2]:
            pred = non_max_suppression(pred, conf_thres, iou_thres, classes, agnostic_nms, max_det=max_det, nm=32)

        # Second-stage classifier (optional)
        # pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)

        ###############################################################################
        ########################## INITIALIZING PREDICTIONS. ##########################
        ###############################################################################
        
        # Process predictions
        for i, det in enumerate(pred):  # per image
            
            # # Detect number of threads
            # if num_threads == 2:
            #     print("Thread: Multi")
            # elif num_threads == 1:
            #     print("Thread: Single")
            
            seen += 1
            p, im0, frame = path[i], im0s[i].copy(), dataset.count
            s += f'{i}: '

            p = Path(p)  # to Path
            # save_path = str(save_dir / p.name)  # im.jpg
            # txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}')  # im.txt
            s += '%gx%g ' % im.shape[2:]  # print string
            annotator = Annotator(im0, line_width=line_thickness, example=str(names))
            if len(det):
                masks = process_mask(proto[i], det[:, 6:], det[:, :4], im.shape[2:], upsample=True)  # HWC
                
                det[:, :4] = scale_boxes(im.shape[2:], det[:, :4], im0.shape).round()  # rescale boxes to im0 size

                masks2 = process_mask(proto[i], det[:, 6:], det[:, :4], imnew.shape[2:], upsample=True)  # HWC
                
                det[:, :4] = scale_boxes(imnew.shape[2:], det[:, :4], im0.shape).round()  # rescale boxes to im0 size

                segments2 = [
                    scale_segments(im0.shape if retina_masks else imnew.shape[2:], x, im0.shape, normalize=False)
                    for x in reversed(masks2segments(masks))] ## UN-NORMALIZED
                
                #NumberOfElements = sizeof(arr) / sizeof(arr[0]);
                #segments2_conver = np.array(segments2, dtype=np.int32)
                #print(segments2_conver)

                segments = [
                    scale_segments(im0.shape if retina_masks else im.shape[2:], x, im0.shape, normalize=True)
                    for x in reversed(masks2segments(masks))] ## NORMALIZED
                
                # Print results
                for c in det[:, 5].unique():
                    n = (det[:, 5] == c).sum()  # detections per class
                    s += f"{n} {names[int(c)]}{'s' * (n > 1)}, "  # add to string
                    colorclass = str(names[int(c)])
                    # g = f"{names[int(c)]}"
                    # cs = str(names[int(c)])
                    # print("Class_3: ", cs)
                    # print(n)

                
                # Mask plotting
                annotator.masks(
                    masks,
                    colors=[colors(x, True) for x in det[:, 5]],
                    im_gpu=torch.as_tensor(im0, dtype=torch.float16).to(device).permute(2, 0, 1).flip(0).contiguous() /
                    255 if retina_masks else im[i])

                ret, new_frame, bgr_image, depth_image, bgr_frame, depth_frame, color_intrin = get_frame_stream()
                # Write results
                for j, (*xyxy, conf, cls) in enumerate(reversed(det[:, :6])):
                    seg = segments[j].reshape(-1)  # (n,2) to (n*2)
                    #print(segments[j])
                    line = (cls, *seg, conf) if save_conf else (cls, *seg)  # label format
                    #with open(f'{txt_path}.txt', 'a') as f:
                        #f.write(('%g ' * len(line)).rstrip() % line + '\n')
                    c = int(cls)  # integer class
                    label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')

                    annotator.box_label(xyxy, label, color=colors(c, True))
                    box = xyxy
                    centerx, centery = int((int(box[0]) + int(box[2])) / 2), int((int(box[1]) + int(box[3])) / 2)
                    center_point = centerx, centery
                    #distance_mm = depth_image[centery, centerx]
                    #print(center_point)
                    #ImageDraw.ImageDraw.polygon(, segments2[j], outline=colors(c, True), width=3)
                    #cv2.circle(vid_cap,(segments2[j]), radius=1, color=(0,0,255), thickness=1)
                    im0 = annotator.result()
                    
                    seg_point = np.array(segments2[j], dtype=np.int32)

                    #cv2.putText(im0, "{} mm".format(distance_mm), (centerx, centery - 10), 0, 0.5, (0, 0, 255), 2)
                    #center_point_XYZ = rs.rs2_deproject_pixel_to_point(color_intrin, center_point, distance_mm)
                    #print(np.array(center_point_XYZ).astype(int))
                    #print("Center point: ", center_point)
                    cv2.polylines(im0, [np.array(segments2[j], dtype=np.int32)], isClosed=True, color=(0,0,0), thickness=3)

                    ##########################################################
                    #################### AREA ESTIMATION. ####################
                    ##########################################################

                    area = cv2.contourArea(seg_point)
                    ctrl_area = area
                    if ctrl_area > 3000 and ctrl_area < 9000:  #OG@5250

                        "So this is the list of segmentation point segments2[j] "
                        #print([np.array(segments2[j], dtype=np.int32)])

                        "So we will move on to do the PCA for detecting vector X,Y for and object"
                        ""
                        ###########################################################
                        ##################### YAW ESTIMATION. #####################
                        ###########################################################

                        ## Performing PCA analysis
                        mean = np.empty((0))
                        mean, eigenvectors, eigenvalues = cv2.PCACompute2(np.array(segments2[j], dtype=np.float64), mean)
                        ## Storing the center of the object
                        cntr = (int(mean[0, 0]), int(mean[0, 1]))

                        ## Drawing the principal components
                        cv2.circle(im0, cntr, 3, PINK, 2)
                        p1 = (cntr[0] + 0.02 * eigenvectors[0, 0] * eigenvalues[0, 0],
                            cntr[1] + 0.02 * eigenvectors[0, 1] * eigenvalues[0, 0])
                        p2 = (cntr[0] - 0.02 * eigenvectors[1, 0] * eigenvalues[1, 0],
                            cntr[1] - 0.02 * eigenvectors[1, 1] * eigenvalues[1, 0])
                        drawAxis(im0, cntr, p1, GREEN, 1)
                        drawAxis(im0, cntr, p2, TEAL, 5)
                        yaw = atan2(eigenvectors[0, 1], eigenvectors[0, 0])  # orientation in radians
                        
                        ##########################################################
                        ##################### SIZE ESTIMATION. ###################
                        ##########################################################

                        # "So in This part we will try to extract the maximum, minimum of coordinates x,y"
                        # "Remember that the highest point Y have the lowest value"
                        # "Remember that the furthest point X have the highest value"
                        # arr = segments2[j]
                        # arr4 = np.max(arr, axis=0)  # find max_y and max_x
                        # arr5 = np.min(arr, axis=0)  # find min_y and min_x

                        # index = np.where(arr == arr4[0])[0]
                        # index1 = np.where(arr == arr4[1])[0]
                        # index2 = np.where(arr == arr5[0])[0]
                        # index3 = np.where(arr == arr5[1])[0]

                        # length = len(index)
                        # length1 = len(index1)
                        # length2 = len(index2)
                        # length3 = len(index3)

                        # # check for top right corner _ check for x
                        # x = (arr[index[0]])
                        # if length > 1:
                        #     for i in range(length - 1):
                        #         x = np.row_stack([x, arr[index[i + 1]]])
                        #     topright_max = np.max(x, axis=0)
                        #     index_xtopright = np.where(x == topright_max[1])[0][0]
                        #     topright_pos = x[index_xtopright]
                        # else:
                        #     topright_pos = x

                        # # check for bot right corner _ check for y
                        # y = (arr[index1[0]])
                        # if length1 > 1:
                        #     for i in range(length1 - 1):
                        #         y = np.row_stack([y, arr[index1[i + 1]]])
                        #     botright_min = np.min(y, axis=0)
                        #     index_ybotright = np.where(y == botright_min[0])[0][0]
                        #     botright_pos = y[index_ybotright]
                        # else:
                        #     botright_pos = y

                        # # check for top lef corner _ check for x
                        # z = (arr[index2[0]])
                        # if length2 > 1:
                        #     for i in range(length2 - 1):
                        #         z = np.row_stack([z, arr[index2[i + 1]]])
                        #     topleft_max = np.max(z, axis=0)
                        #     index_ztopleft = np.where(z == topleft_max[1])[0][0]
                        #     topleft_pos = z[index_ztopleft]
                        # else:
                        #     topleft_pos = z

                        # # check for bot lef corner _ check for y
                        # t = (arr[index3[0]])
                        # if length3 > 1:
                        #     for i in range(length3 - 1):
                        #         t = np.row_stack([t, arr[index3[i + 1]]])
                        #     botlef_min = np.min(t, axis=0)
                        #     index_zbotlef = np.where(t == botlef_min[0])[0][0]
                        #     botlef_pos = t[index_zbotlef]
                        # else:
                        #     botlef_pos = t

                        # cv2.circle(im0, center_point, 3, (255, 0, 0))

                        # distance_1 = depth_image[int(topright_pos[1]), int(topright_pos[0])]
                        # distance_2 = depth_image[int(botright_pos[1]), int(topleft_pos[0])]
                        # distance_3 = depth_image[int(topleft_pos[1]), int(topleft_pos[0])]
                        # distance_4 = depth_image[int(botlef_pos[1]), int(botlef_pos[0])]

                        # point1 = rs.rs2_deproject_pixel_to_point(color_intrin, [topright_pos[0], topright_pos[1]], distance_1)
                        # point2 = rs.rs2_deproject_pixel_to_point(color_intrin, [botright_pos[0], topleft_pos[1]], distance_2)
                        # point3 = rs.rs2_deproject_pixel_to_point(color_intrin, [topleft_pos[0], topleft_pos[1]], distance_3)
                        # point4 = rs.rs2_deproject_pixel_to_point(color_intrin, [botlef_pos[0], botlef_pos[1]], distance_4)

                        # cv2.circle(im0, (int(topright_pos[0]), int(topright_pos[1])), 2, RED)
                        # cv2.circle(im0, (int(botright_pos[0]), int(botright_pos[1])), 2, RED)
                        # cv2.circle(im0, (int(topleft_pos[0]), int(topleft_pos[1])), 2, RED)
                        # cv2.circle(im0, (int(botlef_pos[0]), int(botlef_pos[1])), 2, RED)


                        ##########################################################
                        ################ ROLL, PITCH ESTIMATION. #################
                        ##########################################################

                        offset_x = int((xyxy[2] - xyxy[0])/10)
                        offset_y = int((xyxy[3] - xyxy[1])/10)
                        interval_x = int((xyxy[2] - xyxy[0] -2 * offset_x)/2)
                        interval_y = int((xyxy[3] - xyxy[1] -2 * offset_y)/2)
                        points = np.zeros([9,3]) #OG@[9,3]
                        for i in range(3): #OG@3
                            for j in range(3): #OG@3
                                x = int(xyxy[0]) + offset_x + interval_x*i
                                y = int(xyxy[1]) + offset_y + interval_y*j
                                dist = depth_frame.get_distance(x, y)*1000 #OG@*1000
                                Xtemp = dist*(x - intr.ppx)/intr.fx
                                Ytemp = dist*(y - intr.ppy)/intr.fy
                                Ztemp = dist
                                points[j+i*3][0] = Xtemp
                                points[j+i*3][1] = Ytemp
                                points[j+i*3][2] = Ztemp

                        param = find_plane(points)

                        roll = math.atan(param[2]/param[1])*180/math.pi
                        if(roll < 0):
                            roll = roll + 90
                        else:
                            roll = roll - 90


                        pitch = math.atan(param[2]/param[0])*180/math.pi
                        if(pitch < 0):
                            pitch = pitch + 90
                        else:
                            pitch = pitch - 90

                        
                        ##########################################################
                        ################## X, Y, Z ESTIMATION. ###################
                        ##########################################################

                        object_coordinates = []
                        cx = int((xyxy[0] + xyxy[2])/2)
                        cy = int((xyxy[1] + xyxy[3])/2)
                        dist = depth_frame.get_distance(cx + 0, cy + 0)*1000
                        Xtarget = dist*(cx + 0 - intr.ppx)/intr.fx - 35 #the distance from RGB camera to realsense center
                        Ytarget = dist*(cy + 0 - intr.ppy)/intr.fy
                        Ztarget = dist
                        object_coordinates.append([label, Xtarget, Ztarget])

                        ##########################################################
                        #################### AREA ESTIMATION. ####################
                        ##########################################################

                        # area = cv2.contourArea(seg_point)
                        
                        #########################################################
                        ############## DISPLAYING PARAMETER SECTION. ############
                        #########################################################
                        
                        #print("Totally seen: ", str(len(det)))
                        #print("Class: ", str(names))
                        # class_label = c in det[:, 5].unique()
                        # print("Class_1: ", str(c))
                        # print("Class_2: ", str(class_label))

                        ## Displaying Class parameter ##
                        print("Class: ", colorclass)

                        ## Displaying X,Y,Z parameters ##
                        label_coordinate = "(" + str(round(Xtarget)) + ", " + str(round(Ytarget)) + ", " + str(round(Ztarget)) + ")"
                        cv2.putText(im0, label_coordinate, (int((xyxy[0] + xyxy[2])/2) - 40, int((xyxy[1] + xyxy[3])/2) + 60), cv2.FONT_HERSHEY_PLAIN, 1, WHITE, thickness=1, lineType=cv2.LINE_AA)
                        print("(" + str(round(Xtarget)) + ", " + str(round(Ytarget)) + ", " + str(round(Ztarget)) + ")")

                        ## Displaying Roll, Pitch, Yaw angles and Area ##
                        cvtR2D = np.rad2deg(yaw)
                        label_roll = "Roll: " + str(round(roll, 2))
                        label_pitch = "Pitch: " + str(round(pitch, 2))
                        label_yaw = "Yaw: " + str(round((-int(cvtR2D) - 90), 2))
                        label_area = "Area: "  + str(int(area))
                        cv2.putText(im0, label_roll, (int((xyxy[0] + xyxy[2])/2) - 40, int((xyxy[1] + xyxy[3])/2)), cv2.FONT_HERSHEY_PLAIN, 1, WHITE, thickness=1, lineType=cv2.LINE_AA)
                        cv2.putText(im0, label_pitch, (int((xyxy[0] + xyxy[2])/2) - 40, int((xyxy[1] + xyxy[3])/2) + 20), cv2.FONT_HERSHEY_PLAIN, 1, WHITE, thickness=1, lineType=cv2.LINE_AA)
                        cv2.putText(im0, label_yaw, (int((xyxy[0] + xyxy[2])/2) - 40, int((xyxy[1] + xyxy[3])/2) + 40), cv2.FONT_HERSHEY_PLAIN, 1, WHITE, thickness=1, lineType=cv2.LINE_AA)
                        cv2.putText(im0, label_area, (int((xyxy[0] + xyxy[2])/2) - 40, int((xyxy[1] + xyxy[3])/2) + 80), cv2.FONT_HERSHEY_PLAIN, 1, WHITE, thickness=1, lineType=cv2.LINE_AA)
                        print("Roll: " + str(round(roll, 2)) + ", Pitch: " + str(round(pitch, 2)) + ", Yaw: " + str(round((-int(cvtR2D) - 90), 2)))
                        print("Area: ", area)
                        print("End One detection phase")  
                        print()
                    
                    
            # Stream results
            if view_img:
                if platform.system() == 'Linux' and p not in windows:
                    windows.append(p)
                    cv2.namedWindow(str(p), cv2.WINDOW_NORMAL | cv2.WINDOW_KEEPRATIO)  # allow window resize (Linux)
                    cv2.resizeWindow(str(p), im0.shape[1], im0.shape[0])
                cv2.imshow(str(p), im0)
                if cv2.waitKey(1) == ord('q'):  # 1 millisecond
                    exit()

        # Print time (inference-only)
        LOGGER.info(f"{s}{'' if len(det) else '(no detections), '}{dt[1].dt * 1E3:.1f}ms")
        # LOGGER.info(f"'Class_4: '{g}")
    # Print results
    # t = tuple(x.t / seen * 1E3 for x in dt)  # speeds per image
    # LOGGER.info(f'Seg:%.1fms seg, Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t)
   

# def parse_opt():
#     parser = argparse.ArgumentParser()
#     parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'yolov5s-seg.pt', help='model path(s)')
#     parser.add_argument('--source', type=str, default=ROOT / 'data/images', help='file/dir/URL/glob/screen/0(webcam)')
#     parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='(optional) dataset.yaml path')
#     parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[640], help='inference size h,w')
#     parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')
#     parser.add_argument('--iou-thres', type=float, default=0.45, help='NMS IoU threshold')
#     parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')
#     parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
#     parser.add_argument('--view-img', action='store_true', help='show results')
#     parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
#     parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
#     parser.add_argument('--save-crop', action='store_true', help='save cropped prediction boxes')
#     parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
#     parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')
#     parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
#     parser.add_argument('--augment', action='store_true', help='augmented inference')
#     parser.add_argument('--visualize', action='store_true', help='visualize features')
#     parser.add_argument('--update', action='store_true', help='update all models')
#     parser.add_argument('--project', default=ROOT / 'runs/predict-seg', help='save results to project/name')
#     parser.add_argument('--name', default='exp', help='save results to project/name')
#     parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
#     parser.add_argument('--line-thickness', default=3, type=int, help='bounding box thickness (pixels)')
#     parser.add_argument('--hide-labels', default=False, action='store_true', help='hide labels')
#     parser.add_argument('--hide-conf', default=False, action='store_true', help='hide confidences')
#     parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
#     parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
#     parser.add_argument('--vid-stride', type=int, default=1, help='video frame-rate stride')
#     parser.add_argument('--retina-masks', action='store_true', help='whether to plot masks in native resolution')
#     opt = parser.parse_args()
#     opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1  # expand
#     print_args(vars(opt))
#     return opt


# def main(opt):
#     check_requirements(ROOT / 'requirements.txt', exclude=('tensorboard', 'thop'))
#     run(**vars(opt))

if __name__ == '__main__':
    # opt = parse_opt()
    # main(opt)
    run()
```
But when I execute the code above on Ubuntu 20.04, I get this error:
```
[ WARN:0@4.385] global cap_v4l.cpp:982 open VIDEOIO(V4L2:/dev/video4): can't open camera by index
[ERROR:0@4.501] global obsensor_uvc_stream_channel.cpp:156 getStreamChannelGroup Camera index out of range
Traceback (most recent call last):
  File "train_seg.py", line 9, in <module>
    run(
  File "/home/anthonia/.local/lib/python3.8/site-packages/torch/utils/_contextlib.py", line 115, in decorate_context
    return func(*args, **kwargs)
  File "/home/anthonia/.local/lib/python3.8/site-packages/torch/utils/_contextlib.py", line 115, in decorate_context
    return func(*args, **kwargs)
  File "/home/anthonia/Documents/yolov5-master/Ultimate_2.py", line 175, in run
    dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt, vid_stride=vid_stride)
  File "/home/anthonia/Documents/yolov5-master/utils/dataloaders.py", line 367, in __init__
    assert cap.isOpened(), f'{st}Failed to open {s}'
AssertionError: 1/1: 4... Failed to open 4
```
With the index 4 is the RGB channel of realsense camera. 
I have tried everything, check the dev/video also but I don't know why the program does not works. Here is the list of dev/video
```
crw-rw-rw-+ 1 root plugdev 81, 0 Thg 11 16 10:55 /dev/video0
crw-rw-rw-+ 1 root plugdev 81, 1 Thg 11 16 10:55 /dev/video1
crw-rw-rw-+ 1 root plugdev 81, 2 Thg 11 16 10:55 /dev/video2
crw-rw-rw-+ 1 root plugdev 81, 3 Thg 11 16 10:55 /dev/video3
crw-rw-rw-+ 1 root plugdev 81, 4 Thg 11 16 10:55 /dev/video4
crw-rw-rw-+ 1 root plugdev 81, 5 Thg 11 16 10:55 /dev/video5
crw-rw----+ 1 root video   81, 6 Thg 11 16 10:55 /dev/video6
crw-rw----+ 1 root video   81, 7 Thg 11 16 10:55 /dev/video7
```
And I also have installed the librealsense from source and pip install pyrealsense. Please help me


### Steps to reproduce

I have research all the related issue but they don't work for me. I cannot find the related post about realsense on Ubuntu and Windows. I do not know why it works on Windows.

### Issue submission checklist

- [X] I report the issue, it's not a question
- [X] I checked the problem with documentation, FAQ, open issues, forum.opencv.org, Stack Overflow, etc and have not found any solution
- [X] I updated to the latest OpenCV version and the issue is still there
- [X] There is reproducer code and related data files (videos, images, onnx, etc)