Hello,
I'm in possession of a OAK-D Wide camera for robot navigation application.
My goal is simple : I want to recover the RGB and an aligned filtered depth the fastest way possible at low resolution.
I start with the disparity processing to get the smoothest result; I use a decimation filter of 3 to accelerate the process. (the resulting size is 221x140)
Then I've added the RGB camera output and I set resolution to the same size of the disparity map (eg.camRgb.setPreviewSize(221, 140))
Unfortunately, I get the warning :
[1944301031B09D2E00] [1.1] [0.692] [ColorCamera(0)] [warning] Unsupported resolution set for detected camera OV9782, needs 800_P or 720_P. Defaulting to 800_P
And the following result (processed depth and RGB) is resized to 800_p, which is logical since the disparity is resized to the RGB resolution.
My question : How can I set the RGB resolution to match to the disparity size to get the result the fastest way possible ? Is there a workaround ?
best regards,
Neuro
#!/usr/bin/env python3
import cv2
import depthai as dai
import numpy as np
# Closer-in minimum depth, disparity range is doubled (from 95 to 190):
extended_disparity = False
# Better accuracy for longer distance, fractional disparity 32-levels:
subpixel = True
# Better handling for occlusions:
lr_check = True
# Create pipeline
pipeline = dai.Pipeline()
# Get device
device = dai.Device()
queueNames = []
# Define sources and outputs
camRgb = pipeline.create(dai.node.ColorCamera)
monoLeft = pipeline.create(dai.node.MonoCamera)
monoRight = pipeline.create(dai.node.MonoCamera)
depth = pipeline.create(dai.node.StereoDepth)
color_out = pipeline.create(dai.node.XLinkOut)
disp_out = pipeline.create(dai.node.XLinkOut)
color_out.setStreamName("rgb")
queueNames.append("rgb")
disp_out.setStreamName("disp")
queueNames.append("disp")
# init RGB camera
camRgb.setBoardSocket(dai.CameraBoardSocket.CAM_A)
camRgb.setPreviewSize(221, 140)
camRgb.setFps(60)
# get calibration data
try:
calibData = device.readCalibration2()
lensPosition = calibData.getLensPosition(dai.CameraBoardSocket.CAM_A)
if lensPosition:
camRgb.initialControl.setManualFocus(lensPosition)
except:
raise
# Properties
monoLeft.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
monoLeft.setCamera("left")
monoLeft.setFps(60)
monoRight.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
monoRight.setCamera("right")
monoRight.setFps(60)
# Create a node that will produce the depth map (using disparity output as it's easier to visualize depth this way)
depth.setDefaultProfilePreset(dai.node.StereoDepth.PresetMode.HIGH_DENSITY)
depth.initialConfig.setMedianFilter(dai.MedianFilter.MEDIAN_OFF)
depth.setLeftRightCheck(lr_check)
depth.setExtendedDisparity(extended_disparity)
depth.setSubpixel(subpixel)
depth.setSubpixelFractionalBits(3)
# align color + depth data
depth.setDepthAlign(dai.CameraBoardSocket.CAM_A)
# Init post processing spatial filter
config = depth.initialConfig.get()
config.postProcessing.spatialFilter.enable = True
config.postProcessing.spatialFilter.holeFillingRadius = 8
config.postProcessing.spatialFilter.numIterations = 3
config.postProcessing.thresholdFilter.minRange = 400
config.postProcessing.thresholdFilter.maxRange = 4000
config.postProcessing.decimationFilter.decimationFactor = 3
depth.initialConfig.set(config)
# Linking
camRgb.video.link(color_out.input)
monoLeft.out.link(depth.left)
monoRight.out.link(depth.right)
depth.disparity.link(disp_out.input)
# Connect to device and start pipeline
with device:
# start pipeline
device.startPipeline(pipeline)
# init frame
frame_RGB = None
frame_disp = None
# init cv2 windows
cv2.namedWindow("RGB")
cv2.namedWindow("Depth")
while True:
latestPacket = {}
latestPacket["rgb"] = None
latestPacket["disp"] = None
queueEvents = device.getQueueEvents(("rgb", "disp"))
for queueName in queueEvents:
packets = device.getOutputQueue(queueName).tryGetAll()
if len(packets) > 0:
latestPacket[queueName] = packets[-1]
if latestPacket["rgb"] is not None:
frame_RGB = latestPacket["rgb"].getCvFrame()
# plot result
cv2.imshow("RGB", frame_RGB)
if latestPacket["disp"] is not None:
frame_disp = latestPacket["disp"].getFrame()
frame_disp = (frame_disp * (255 / depth.initialConfig.getMaxDisparity())).astype(np.uint8)
frame_disp = cv2.applyColorMap(frame_disp, cv2.COLORMAP_JET)
cv2.imshow("Depth", frame_disp)
if cv2.waitKey(1) == ord('q'):
break
