def create_pipeline():
print("Creating pipeline...")
pipeline = depthai.Pipeline()
if args.camera:
# ColorCamera
print("Creating Color Camera...")
cam = pipeline.createColorCamera()
cam.setPreviewSize(300, 300)
cam.setResolution(
depthai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setInterleaved(False)
cam.setBoardSocket(depthai.CameraBoardSocket.RGB)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName("cam_out")
cam.preview.link(cam_xout.input)
# NeuralNetwork
print("Creating Face Detection Neural Network...")
detection_nn = pipeline.createMobileNetDetectionNetwork()
detection_nn.setConfidenceThreshold(0.5)
detection_nn.setBlobPath(
str(
blobconverter.from_zoo(name="face-detection-retail-0004",
shaves=6 if args.camera else 8)))
detection_nn_xout = pipeline.createXLinkOut()
detection_nn_xout.setStreamName("detection_nn")
detection_nn.out.link(detection_nn_xout.input)
if args.camera:
cam.preview.link(detection_nn.input)
else:
detection_in = pipeline.createXLinkIn()
detection_in.setStreamName("detection_in")
detection_in.out.link(detection_nn.input)
# NeuralNetwork
print("Creating Age Gender Neural Network...")
age_gender_in = pipeline.createXLinkIn()
age_gender_in.setStreamName("age_gender_in")
age_gender_nn = pipeline.createNeuralNetwork()
age_gender_nn.setBlobPath(
str(
blobconverter.from_zoo(name="age-gender-recognition-retail-0013",
shaves=6 if args.camera else 8)))
age_gender_nn_xout = pipeline.createXLinkOut()
age_gender_nn_xout.setStreamName("age_gender_nn")
age_gender_in.out.link(age_gender_nn.input)
age_gender_nn.out.link(age_gender_nn_xout.input)
print("Pipeline created.")
return pipeline
def getPipeline():
# Start defining a pipeline
pipeline = dai.Pipeline()
# Define a source - color camera
cam_rgb = pipeline.createColorCamera()
# For the demo, just set a larger RGB preview size for OAK-D
cam_rgb.setPreviewSize(300, 300)
cam_rgb.setBoardSocket(dai.CameraBoardSocket.RGB)
cam_rgb.setResolution(
dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam_rgb.setInterleaved(False)
detector = pipeline.createMobileNetDetectionNetwork()
detector.setConfidenceThreshold(0.5)
detector.setBlobPath(blobconverter.from_zoo(name="mobilenet-ssd",
shaves=6))
cam_rgb.preview.link(detector.input)
# Create output
xout_rgb = pipeline.createXLinkOut()
xout_rgb.setStreamName("rgb")
detector.passthrough.link(xout_rgb.input)
xout_nn = pipeline.createXLinkOut()
xout_nn.setStreamName("nn")
detector.out.link(xout_nn.input)
return pipeline
def create_pipeline(video):
pipeline = dai.Pipeline()
# pipeline.setOpenVINOVersion(dai.OpenVINO.VERSION_2021_4)
mesh = pipeline.create(dai.node.NeuralNetwork)
mesh.setBlobPath("models/face_landmark_openvino_2021.4_6shave.blob")
mesh.setNumInferenceThreads(2)
mesh.input.setBlocking(False)
mesh.input.setQueueSize(2)
if video:
mesh_in = pipeline.create(dai.node.XLinkIn)
mesh_in.setStreamName("mesh_in")
mesh_in.setMaxDataSize(192 * 192 * 3)
mesh_in.out.link(mesh.input)
else:
cam = pipeline.create(dai.node.ColorCamera)
cam.setResolution(
dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setBoardSocket(dai.CameraBoardSocket.RGB)
cam.setInterleaved(False)
cam.setPreviewSize(preview_size)
cam_out = pipeline.create(dai.node.XLinkOut)
cam_out.setStreamName("rgb")
cam.preview.link(cam_out.input)
manip = pipeline.create(dai.node.ImageManip)
manip.initialConfig.setResize(192, 192)
cam.preview.link(manip.inputImage)
manip.out.link(mesh.input)
# cam.preview.link(face_det.input)
mesh_out = pipeline.create(dai.node.XLinkOut)
mesh_out.setStreamName("mesh_nn")
mesh.out.link(mesh_out.input)
eye = pipeline.create(dai.node.NeuralNetwork)
eye.setBlobPath(
blobconverter.from_zoo(
"open-closed-eye-0001",
shaves=6,
# version=pipeline.getOpenVINOVersion()
))
eye.setNumInferenceThreads(2)
eye.input.setBlocking(False)
eye.input.setQueueSize(2)
eye_in = pipeline.create(dai.node.XLinkIn)
eye_in.setStreamName("eye_in")
eye_in.setMaxDataSize(32 * 32 * 3)
eye_in.out.link(eye.input)
eye_out = pipeline.create(dai.node.XLinkOut)
eye_out.setStreamName("eye_nn")
eye.out.link(eye_out.input)
return pipeline
def create_pipeline(self, model_name):
log.info("Creating DepthAI pipeline...")
pipeline = dai.Pipeline()
#pipeline.setOpenVINOVersion(dai.OpenVINO.Version.VERSION_2021_2)
# Define sources and outputs
camRgb = pipeline.createColorCamera()
spatialDetectionNetwork = pipeline.createMobileNetSpatialDetectionNetwork(
)
monoLeft = pipeline.createMonoCamera()
monoRight = pipeline.createMonoCamera()
stereo = pipeline.createStereoDepth()
xoutRgb = pipeline.createXLinkOut()
camRgb.preview.link(xoutRgb.input)
xoutNN = pipeline.createXLinkOut()
xoutRgb.setStreamName("rgb")
xoutNN.setStreamName("detections")
# Properties
camRgb.setPreviewSize(544, 320)
camRgb.setResolution(
dai.ColorCameraProperties.SensorResolution.THE_1080_P)
camRgb.setInterleaved(False)
camRgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.BGR)
monoLeft.setResolution(
dai.MonoCameraProperties.SensorResolution.THE_400_P)
monoLeft.setBoardSocket(dai.CameraBoardSocket.LEFT)
monoRight.setResolution(
dai.MonoCameraProperties.SensorResolution.THE_400_P)
monoRight.setBoardSocket(dai.CameraBoardSocket.RIGHT)
# Setting node configs
stereo.setConfidenceThreshold(255)
spatialDetectionNetwork.setBlobPath(
blobconverter.from_zoo(name=model_name, shaves=6))
spatialDetectionNetwork.setConfidenceThreshold(0.5)
spatialDetectionNetwork.input.setBlocking(False)
spatialDetectionNetwork.setBoundingBoxScaleFactor(0.5)
spatialDetectionNetwork.setDepthLowerThreshold(100)
spatialDetectionNetwork.setDepthUpperThreshold(5000)
# Linking
monoLeft.out.link(stereo.left)
monoRight.out.link(stereo.right)
camRgb.preview.link(spatialDetectionNetwork.input)
spatialDetectionNetwork.out.link(xoutNN.input)
stereo.depth.link(spatialDetectionNetwork.inputDepth)
log.info("Pipeline created.")
return pipeline
def create_pipeline():
print("Creating pipeline...")
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.Version.VERSION_2021_3)
# ColorCamera
print("Creating Color Camera...")
cam = pipeline.create(dai.node.ColorCamera)
cam.setPreviewSize(300, 300)
cam.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setVideoSize(1080, 1080)
cam.setInterleaved(False)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName("frame")
cam.video.link(cam_xout.input)
# NeuralNetwork
print("Creating Face Detection Neural Network...")
face_det_nn = pipeline.create(dai.node.MobileNetDetectionNetwork)
face_det_nn.setConfidenceThreshold(0.5)
face_det_nn.setBlobPath(
blobconverter.from_zoo(name="face-detection-retail-0004",
shaves=6,
version='2021.3'))
# Link Face ImageManip -> Face detection NN node
cam.preview.link(face_det_nn.input)
objectTracker = pipeline.createObjectTracker()
objectTracker.setDetectionLabelsToTrack([1]) # track only person
# possible tracking types: ZERO_TERM_COLOR_HISTOGRAM, ZERO_TERM_IMAGELESS, SHORT_TERM_IMAGELESS, SHORT_TERM_KCF
objectTracker.setTrackerType(dai.TrackerType.ZERO_TERM_COLOR_HISTOGRAM)
# take the smallest ID when new object is tracked, possible options: SMALLEST_ID, UNIQUE_ID
objectTracker.setTrackerIdAssigmentPolicy(
dai.TrackerIdAssigmentPolicy.SMALLEST_ID)
# Linking
face_det_nn.passthrough.link(objectTracker.inputDetectionFrame)
face_det_nn.passthrough.link(objectTracker.inputTrackerFrame)
face_det_nn.out.link(objectTracker.inputDetections)
# Send face detections to the host (for bounding boxes)
pass_xout = pipeline.create(dai.node.XLinkOut)
pass_xout.setStreamName("pass_out")
objectTracker.passthroughTrackerFrame.link(pass_xout.input)
tracklets_xout = pipeline.create(dai.node.XLinkOut)
tracklets_xout.setStreamName("tracklets")
objectTracker.out.link(tracklets_xout.input)
print("Pipeline created.")
return pipeline
def create_pipeline():
print("Creating pipeline...")
pipeline = depthai.Pipeline()
if camera:
print("Creating Color Camera...")
cam = pipeline.createColorCamera()
cam.setPreviewSize(300, 300)
cam.setResolution(
depthai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setInterleaved(False)
cam.setBoardSocket(depthai.CameraBoardSocket.RGB)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName("cam_out")
cam.preview.link(cam_xout.input)
first_models(
cam,
pipeline,
blobconverter.from_zoo("face-detection-retail-0004", shaves=6),
"face",
)
else:
models(
pipeline,
blobconverter.from_zoo("face-detection-retail-0004", shaves=8),
"face",
)
models(
pipeline,
blobconverter.from_openvino(
"models/face_landmark_160x160.xml",
"models/face_landmark_160x160.bin",
shaves=shaves,
),
"land68",
)
return pipeline
def compile(self, shaves, target='auto'):
if self.use_zoo:
return blobconverter.from_zoo(name=self.model_name, shaves=shaves)
else:
return blobconverter.compile_blob(
blob_name=self.model_name,
req_data={
"name": self.model_name,
"use_zoo": True,
},
req_files={
'config': self.config_file,
},
data_type="FP16",
shaves=shaves,
)
def create_nns(self):
self.create_mobilenet_nn(
blobconverter.from_zoo("face-detection-retail-0004",
shaves=shaves),
"face",
first=True,
)
# https://github.com/sbdcv/sbd_mask/tree/master/model
# https://github.com/sbdcv/sbd_mask/blob/8e25fbd550339857f6466016d3ed0866e759ab47/deploy.py#L11-L12
self.create_nn(
blobconverter.from_onnx(
(Path(__file__).parent /
Path("models/sbd_mask.onnx")).as_posix(),
optimizer_params=[
"--scale_values=[255,255,255]",
"--reverse_input_channels",
],
shaves=shaves,
),
"mask",
)
def __init__(self, application, pc_id, options):
super().__init__(application, pc_id, options)
self.frame = np.zeros((self.options.height, self.options.width, 3),
np.uint8)
self.frame[:] = (0, 0, 0)
self.detections = []
self.pipeline = dai.Pipeline()
self.camRgb = self.pipeline.createColorCamera()
self.xoutRgb = self.pipeline.createXLinkOut()
self.xoutRgb.setStreamName("rgb")
# Properties
self.camRgb.setPreviewSize(self.options.width, self.options.height)
self.camRgb.setInterleaved(False)
self.camRgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.RGB)
# Linking
self.camRgb.preview.link(self.xoutRgb.input)
self.nn = None
if options.nn != "":
self.nn = self.pipeline.createMobileNetDetectionNetwork()
self.nn.setConfidenceThreshold(0.5)
self.nn.setBlobPath(
str(blobconverter.from_zoo(options.nn, shaves=6)))
self.nn.setNumInferenceThreads(2)
self.nn.input.setBlocking(False)
self.nnOut = self.pipeline.createXLinkOut()
self.nnOut.setStreamName("nn")
self.camRgb.preview.link(self.nn.input)
self.nn.out.link(self.nnOut.input)
self.device = dai.Device(self.pipeline)
self.qRgb = self.device.getOutputQueue(name="rgb",
maxSize=1,
blocking=False)
if self.nn is not None:
self.qDet = self.device.getOutputQueue(name="nn",
maxSize=4,
blocking=False)
self.device.startPipeline()
for y_col in channel for val in y_col
]
# Start defining a pipeline
pipeline = dai.Pipeline()
# Define a source - color camera
cam_rgb = pipeline.createColorCamera()
cam_rgb.setPreviewSize(300, 300)
cam_rgb.setInterleaved(False)
# Define a neural network that will make predictions based on the source frames
detection_nn = pipeline.createNeuralNetwork()
detection_nn.setBlobPath(
str(blobconverter.from_zoo(name="face-detection-retail-0004", shaves=6)))
cam_rgb.preview.link(detection_nn.input)
landmarks_nn = pipeline.createNeuralNetwork()
landmarks_nn.setBlobPath(
str(
blobconverter.from_zoo(name="landmarks-regression-retail-0009",
shaves=6)))
# Create outputs
xin_rgb = pipeline.createXLinkIn()
xin_rgb.setStreamName("land_in")
xin_rgb.out.link(landmarks_nn.input)
# Create outputs
xout_frame = pipeline.createXLinkOut()
def create_depthai_pipeline():
# Start defining a pipeline
pipeline = dai.Pipeline()
# Define a source - two mono (grayscale) cameras
left = pipeline.createMonoCamera()
left.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
left.setBoardSocket(dai.CameraBoardSocket.LEFT)
right = pipeline.createMonoCamera()
right.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
# Create a node that will produce the depth map
depth = pipeline.createStereoDepth()
depth.setConfidenceThreshold(200)
depth.setOutputRectified(
True) # The rectified streams are horizontally mirrored by default
depth.setRectifyEdgeFillColor(0) # Black, to better see the cutout
depth.setExtendedDisparity(True) # For better close range depth perception
median = dai.StereoDepthProperties.MedianFilter.KERNEL_7x7 # For depth filtering
depth.setMedianFilter(median)
# Linking mono cameras with depth node
left.out.link(depth.left)
right.out.link(depth.right)
# Create left output
xOutRight = pipeline.createXLinkOut()
xOutRight.setStreamName("right")
depth.rectifiedRight.link(xOutRight.input)
# Create depth output
xOutDisp = pipeline.createXLinkOut()
xOutDisp.setStreamName("disparity")
depth.disparity.link(xOutDisp.input)
# Create input and output node for Depth Classification
xDepthIn = pipeline.createXLinkIn()
xDepthIn.setStreamName("depth_in")
xOutDepthNn = pipeline.createXLinkOut()
xOutDepthNn.setStreamName("depth_nn")
# Define Depth Classification NN node
depthNn = pipeline.createNeuralNetwork()
depthNn.setBlobPath(
"data/depth-classification-models/depth_classification_ipscaled_model.blob"
)
depthNn.input.setBlocking(False)
# Linking
xDepthIn.out.link(depthNn.input)
depthNn.out.link(xOutDepthNn.input)
# Convert detection model from OMZ to blob
if DET_MODEL_NAME is not None:
facedet_blob_path = blobconverter.from_zoo(name=DET_MODEL_NAME,
shaves=6,
zoo_type=DET_ZOO_TYPE)
# Create Face Detection NN node
faceDetNn = pipeline.createMobileNetDetectionNetwork()
faceDetNn.setConfidenceThreshold(0.75)
faceDetNn.setBlobPath(facedet_blob_path)
# Create ImageManip to convert grayscale mono camera frame to RGB
copyManip = pipeline.createImageManip()
depth.rectifiedRight.link(copyManip.inputImage)
# copyManip.initialConfig.setHorizontalFlip(True)
copyManip.initialConfig.setFrameType(dai.RawImgFrame.Type.RGB888p)
# Create ImageManip to preprocess input frame for detection NN
detManip = pipeline.createImageManip()
# detManip.initialConfig.setHorizontalFlip(True)
detManip.initialConfig.setResize(DET_INPUT_SIZE[0], DET_INPUT_SIZE[1])
detManip.initialConfig.setKeepAspectRatio(False)
# Linking detection ImageManip to detection NN
copyManip.out.link(detManip.inputImage)
detManip.out.link(faceDetNn.input)
# Create output steam for detection output
xOutDet = pipeline.createXLinkOut()
xOutDet.setStreamName('det_out')
faceDetNn.out.link(xOutDet.input)
# Script node will take the output from the face detection NN as an input and set ImageManipConfig
# to crop the initial frame for recognition NN
script = pipeline.create(dai.node.Script)
script.setProcessor(dai.ProcessorType.LEON_CSS)
script.setScriptPath("script.py")
# Set inputs for script node
copyManip.out.link(script.inputs['frame'])
faceDetNn.out.link(script.inputs['face_det_in'])
# Convert recognition model from OMZ to blob
if REC_MODEL_NAME is not None:
facerec_blob_path = blobconverter.from_zoo(name=REC_MODEL_NAME,
shaves=6,
zoo_type=REC_ZOO_TYPE)
# Create Face Recognition NN node
faceRecNn = pipeline.createNeuralNetwork()
faceRecNn.setBlobPath(facerec_blob_path)
# Create ImageManip to preprocess frame for recognition NN
recManip = pipeline.createImageManip()
# Set recognition ImageManipConfig from script node
script.outputs['manip_cfg'].link(recManip.inputConfig)
script.outputs['manip_img'].link(recManip.inputImage)
# Create output steam for recognition output
xOutRec = pipeline.createXLinkOut()
xOutRec.setStreamName('rec_out')
faceRecNn.out.link(xOutRec.input)
recManip.out.link(faceRecNn.input)
return pipeline
def draw(data, frame):
if len(data) == 0:
return
cv2.addWeighted(frame, 1, cv2.resize(data, frame.shape[:2][::-1]), 0.2, 0,
frame)
# Start defining a pipeline
pm = PipelineManager()
pm.createColorCam(previewSize=nn_shape)
nm = NNetManager(inputSize=nn_shape)
pm.setNnManager(nm)
pm.addNn(nm.createNN(
pm.pipeline, pm.nodes,
blobconverter.from_zoo(name='road-segmentation-adas-0001', shaves=6)),
sync=True)
fps = FPSHandler()
pv = PreviewManager(display=[Previews.color.name], fpsHandler=fps)
# Pipeline is defined, now we can connect to the device
with dai.Device(pm.pipeline) as device:
nm.createQueues(device)
pv.createQueues(device)
while True:
fps.tick('color')
pv.prepareFrames(blocking=True)
frame = pv.get(Previews.color.name)
road_decoded = decode(nm.outputQueue.get())
'''
# --------------- Arguments ---------------
parser = argparse.ArgumentParser()
parser.add_argument("-w",
"--width",
help="select model width for inference",
default=320,
type=int)
args = parser.parse_args()
# choose width and height based on model
if args.width == 320:
NN_WIDTH, NN_HEIGHT = 320, 256
NN_PATH = blobconverter.from_zoo(name="fast_depth_256x320",
zoo_type="depthai")
elif args.width == 640:
NN_WIDTH, NN_HEIGHT = 640, 480
NN_PATH = blobconverter.from_zoo(name="fast_depth_480x640",
zoo_type="depthai")
else:
raise ValueError(f"Width can be only 320 or 640, not {args.width}")
# --------------- Pipeline ---------------
# Start defining a pipeline
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.VERSION_2021_4)
# Define a neural network
detection_nn = pipeline.createNeuralNetwork()
detection_nn.setBlobPath(str(NN_PATH))
def create_pipeline(depth):
# Start defining a pipeline
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.Version.VERSION_2021_2)
# Define a source - color camera
colorCam = pipeline.createColorCamera()
if depth:
mobilenet = pipeline.createMobileNetSpatialDetectionNetwork()
monoLeft = pipeline.createMonoCamera()
monoRight = pipeline.createMonoCamera()
stereo = pipeline.createStereoDepth()
else:
mobilenet = pipeline.createMobileNetDetectionNetwork()
colorCam.setPreviewSize(300, 300)
colorCam.setResolution(
dai.ColorCameraProperties.SensorResolution.THE_1080_P)
colorCam.setInterleaved(False)
colorCam.setColorOrder(dai.ColorCameraProperties.ColorOrder.BGR)
mobilenet.setBlobPath(
str(blobconverter.from_zoo("mobilenet-ssd", shaves=6,
version="2021.2")))
mobilenet.setConfidenceThreshold(0.5)
mobilenet.input.setBlocking(False)
if depth:
monoLeft.setResolution(
dai.MonoCameraProperties.SensorResolution.THE_400_P)
monoLeft.setBoardSocket(dai.CameraBoardSocket.LEFT)
monoRight.setResolution(
dai.MonoCameraProperties.SensorResolution.THE_400_P)
monoRight.setBoardSocket(dai.CameraBoardSocket.RIGHT)
# Setting node configs
stereo.initialConfig.setConfidenceThreshold(255)
stereo.depth.link(mobilenet.inputDepth)
mobilenet.setBoundingBoxScaleFactor(0.5)
mobilenet.setDepthLowerThreshold(100)
mobilenet.setDepthUpperThreshold(5000)
monoLeft.out.link(stereo.left)
monoRight.out.link(stereo.right)
xoutRgb = pipeline.createXLinkOut()
xoutRgb.setStreamName("rgb")
colorCam.preview.link(mobilenet.input)
if syncNN:
mobilenet.passthrough.link(xoutRgb.input)
else:
colorCam.preview.link(xoutRgb.input)
xoutNN = pipeline.createXLinkOut()
xoutNN.setStreamName("detections")
mobilenet.out.link(xoutNN.input)
if depth:
xoutBoundingBoxDepthMapping = pipeline.createXLinkOut()
xoutBoundingBoxDepthMapping.setStreamName("boundingBoxDepthMapping")
mobilenet.boundingBoxMapping.link(xoutBoundingBoxDepthMapping.input)
xoutDepth = pipeline.createXLinkOut()
xoutDepth.setStreamName("depth")
mobilenet.passthroughDepth.link(xoutDepth.input)
return pipeline
def create_pipeline():
print("Creating pipeline...")
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.Version.VERSION_2021_3)
# ColorCamera
print("Creating Color Camera...")
cam = pipeline.create(dai.node.ColorCamera)
cam.setPreviewSize(300, 300)
cam.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setVideoSize(1080,1080)
cam.setInterleaved(False)
controlIn = pipeline.createXLinkIn()
controlIn.setStreamName('control')
controlIn.out.link(cam.inputControl)
left = pipeline.createMonoCamera()
left.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
left.setBoardSocket(dai.CameraBoardSocket.LEFT)
right = pipeline.createMonoCamera()
right.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
stereo = pipeline.createStereoDepth()
stereo.initialConfig.setConfidenceThreshold(240)
stereo.setExtendedDisparity(True)
left.out.link(stereo.left)
right.out.link(stereo.right)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName("frame")
cam.video.link(cam_xout.input)
# NeuralNetwork
print("Creating Face Detection Neural Network...")
face_det_nn = pipeline.createMobileNetSpatialDetectionNetwork()
face_det_nn.setConfidenceThreshold(0.4)
face_det_nn.setBlobPath(blobconverter.from_zoo(
name="face-detection-retail-0004",
shaves=6,
version='2021.3'
))
face_det_nn.setBoundingBoxScaleFactor(0.5)
face_det_nn.setDepthLowerThreshold(200)
face_det_nn.setDepthUpperThreshold(3000)
cam.preview.link(face_det_nn.input)
stereo.depth.link(face_det_nn.inputDepth)
pass_xout = pipeline.create(dai.node.XLinkOut)
pass_xout.setStreamName("pass_out")
face_det_nn.passthrough.link(pass_xout.input)
nn_xout = pipeline.create(dai.node.XLinkOut)
nn_xout.setStreamName("nn_out")
face_det_nn.out.link(nn_xout.input)
if DEBUG:
bb_xout = pipeline.create(dai.node.XLinkOut)
bb_xout.setStreamName('bb')
face_det_nn.boundingBoxMapping.link(bb_xout.input)
pass_xout = pipeline.create(dai.node.XLinkOut)
pass_xout.setStreamName('pass')
face_det_nn.passthroughDepth.link(pass_xout.input)
print("Pipeline created.")
return pipeline
controlIn = pipeline.createXLinkIn()
controlIn.setStreamName('control')
controlIn.out.link(colorCam.inputControl)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName('video')
colorCam.video.link(cam_xout.input)
# ---------------------------------------
# 1st stage NN - text-detection
# ---------------------------------------
nn = pipeline.createNeuralNetwork()
nn.setBlobPath(
blobconverter.from_zoo(name="east_text_detection_256x256",
zoo_type="depthai",
shaves=6,
version=version))
nn.setNumPoolFrames(1)
colorCam.preview.link(nn.input)
det_passthrough_xout = pipeline.createXLinkOut()
det_passthrough_xout.setStreamName('det_passthrough')
# Only send metadata, we are only interested in timestamp, so we can sync
# depth frames with NN output
det_passthrough_xout.setMetadataOnly(True)
nn.passthrough.link(det_passthrough_xout.input)
nn_xout = pipeline.createXLinkOut()
nn_xout.setStreamName('detections')
nn.out.link(nn_xout.input)
def create_pipeline():
print("Creating pipeline...")
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.Version.VERSION_2020_3)
if args.camera:
print("Creating Color Camera...")
cam = pipeline.createColorCamera()
cam.setPreviewSize(672, 384)
cam.setResolution(
dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setInterleaved(False)
cam.setBoardSocket(dai.CameraBoardSocket.RGB)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName("cam_out")
cam.preview.link(cam_xout.input)
# NeuralNetwork
print("Creating License Plates Detection Neural Network...")
det_nn = pipeline.createMobileNetDetectionNetwork()
det_nn.setConfidenceThreshold(0.5)
det_nn.setBlobPath(
str(
blobconverter.from_zoo(
name="vehicle-license-plate-detection-barrier-0106",
shaves=4,
version=openvino_version)))
det_nn.input.setQueueSize(1)
det_nn.input.setBlocking(False)
det_nn_xout = pipeline.createXLinkOut()
det_nn_xout.setStreamName("det_nn")
det_nn.out.link(det_nn_xout.input)
det_pass = pipeline.createXLinkOut()
det_pass.setStreamName("det_pass")
det_nn.passthrough.link(det_pass.input)
if args.camera:
manip = pipeline.createImageManip()
manip.initialConfig.setResize(300, 300)
manip.initialConfig.setFrameType(dai.RawImgFrame.Type.BGR888p)
cam.preview.link(manip.inputImage)
manip.out.link(det_nn.input)
else:
det_xin = pipeline.createXLinkIn()
det_xin.setStreamName("det_in")
det_xin.out.link(det_nn.input)
# NeuralNetwork
print("Creating Vehicle Detection Neural Network...")
veh_nn = pipeline.createMobileNetDetectionNetwork()
veh_nn.setConfidenceThreshold(0.5)
veh_nn.setBlobPath(
str(
blobconverter.from_zoo(name="vehicle-detection-adas-0002",
shaves=4,
version=openvino_version)))
veh_nn.input.setQueueSize(1)
veh_nn.input.setBlocking(False)
veh_nn_xout = pipeline.createXLinkOut()
veh_nn_xout.setStreamName("veh_nn")
veh_nn.out.link(veh_nn_xout.input)
veh_pass = pipeline.createXLinkOut()
veh_pass.setStreamName("veh_pass")
veh_nn.passthrough.link(veh_pass.input)
if args.camera:
cam.preview.link(veh_nn.input)
else:
veh_xin = pipeline.createXLinkIn()
veh_xin.setStreamName("veh_in")
veh_xin.out.link(veh_nn.input)
rec_nn = pipeline.createNeuralNetwork()
rec_nn.setBlobPath(
str(
blobconverter.from_zoo(
name="license-plate-recognition-barrier-0007",
shaves=4,
version=openvino_version)))
rec_nn.input.setBlocking(False)
rec_nn.input.setQueueSize(1)
rec_xout = pipeline.createXLinkOut()
rec_xout.setStreamName("rec_nn")
rec_nn.out.link(rec_xout.input)
rec_pass = pipeline.createXLinkOut()
rec_pass.setStreamName("rec_pass")
rec_nn.passthrough.link(rec_pass.input)
rec_xin = pipeline.createXLinkIn()
rec_xin.setStreamName("rec_in")
rec_xin.out.link(rec_nn.input)
attr_nn = pipeline.createNeuralNetwork()
attr_nn.setBlobPath(
str(
blobconverter.from_zoo(
name="vehicle-attributes-recognition-barrier-0039",
shaves=4,
version=openvino_version)))
attr_nn.input.setBlocking(False)
attr_nn.input.setQueueSize(1)
attr_xout = pipeline.createXLinkOut()
attr_xout.setStreamName("attr_nn")
attr_nn.out.link(attr_xout.input)
attr_pass = pipeline.createXLinkOut()
attr_pass.setStreamName("attr_pass")
attr_nn.passthrough.link(attr_pass.input)
attr_xin = pipeline.createXLinkIn()
attr_xin.setStreamName("attr_in")
attr_xin.out.link(attr_nn.input)
print("Pipeline created.")
return pipeline
import numpy as np
# Get argument first
# Start defining a pipeline
pipeline = dai.Pipeline()
# Define a source - color camera
cam_rgb = pipeline.createColorCamera()
cam_rgb.setPreviewSize(300, 300)
cam_rgb.setInterleaved(False)
# Define a neural network that will make predictions based on the source frames
detection_nn = pipeline.createMobileNetDetectionNetwork()
detection_nn.setConfidenceThreshold(0.5)
detection_nn.setBlobPath(
blobconverter.from_zoo(name="mobilenet-ssd", shaves=13))
cam_rgb.preview.link(detection_nn.input)
# Create outputs
xout_rgb = pipeline.createXLinkOut()
xout_rgb.setStreamName("rgb")
cam_rgb.preview.link(xout_rgb.input)
xout_nn = pipeline.createXLinkOut()
xout_nn.setStreamName("nn")
detection_nn.out.link(xout_nn.input)
# MobilenetSSD label texts
texts = [
"background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus",
"car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike",
import subprocess
import sys
import shutil
import blobconverter
use_cache = False
if not use_cache:
shutil.rmtree(blobconverter.__defaults["output_dir"])
result = blobconverter.from_zoo(name="face-detection-retail-0004",
shaves=3,
use_cache=use_cache)
print(result)
result = blobconverter.from_caffe(
proto=
"../../mobilenet-ssd.prototxt", # get from https://drive.google.com/file/d/0B3gersZ2cHIxRm5PMWRoTkdHdHc
model=
"../../mobilenet-ssd.caffemodel", # get from https://raw.githubusercontent.com/chuanqi305/MobileNet-SSD/ba00fc987b3eb0ba87bb99e89bf0298a2fd10765/MobileNetSSD_deploy.prototxt
data_type="FP16",
shaves=5,
use_cache=use_cache,
)
print(result)
result = blobconverter.from_openvino(
xml=
"../../face-detection-retail-0004.xml", # get from https://storage.openvinotoolkit.org/repositories/open_model_zoo/2021.2/models_bin/3/face-detection-retail-0004/FP16/face-detection-retail-0004.xml
bin=
"../../face-detection-retail-0004.bin", # get from https://storage.openvinotoolkit.org/repositories/open_model_zoo/2021.2/models_bin/3/face-detection-retail-0004/FP16/face-detection-retail-0004.bin
def create_pipeline():
print("Creating pipeline...")
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.Version.VERSION_2021_2)
openvino_version = '2021.2'
print("Creating Color Camera...")
cam = pipeline.create(dai.node.ColorCamera)
# For ImageManip rotate you need input frame of multiple of 16
cam.setPreviewSize(1072, 1072)
cam.setVideoSize(VIDEO_SIZE)
cam.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam.setInterleaved(False)
cam.setBoardSocket(dai.CameraBoardSocket.RGB)
cam.setFps(5)
host_face_out = pipeline.create(dai.node.XLinkOut)
host_face_out.setStreamName('frame')
cam.video.link(host_face_out.input)
# ImageManip that will crop the frame before sending it to the Face detection NN node
face_det_manip = pipeline.create(dai.node.ImageManip)
face_det_manip.initialConfig.setResize(300, 300)
face_det_manip.initialConfig.setFrameType(dai.RawImgFrame.Type.RGB888p)
# NeuralNetwork
print("Creating Face Detection Neural Network...")
face_det_nn = pipeline.create(dai.node.MobileNetDetectionNetwork)
face_det_nn.setConfidenceThreshold(0.5)
face_det_nn.setBlobPath(
blobconverter.from_zoo(name="face-detection-retail-0004",
shaves=6,
version=openvino_version))
# Link Face ImageManip -> Face detection NN node
face_det_manip.out.link(face_det_nn.input)
# Script node will take the output from the face detection NN as an input and set ImageManipConfig
# to the 'age_gender_manip' to crop the initial frame
script = pipeline.create(dai.node.Script)
face_det_nn.out.link(script.inputs['face_det_in'])
face_detections_out = pipeline.create(dai.node.XLinkOut)
face_detections_out.setStreamName('detections')
face_det_nn.out.link(face_detections_out.input)
# We are only interested in timestamp, so we can sync depth frames with NN output
face_det_nn.passthrough.link(script.inputs['face_pass'])
with open("script.py", "r") as f:
script.setScript(f.read())
# ImageManip as a workaround to have more frames in the pool.
# cam.preview can only have 4 frames in the pool before it will
# wait (freeze). Copying frames and setting ImageManip pool size to
# higher number will fix this issue.
copy_manip = pipeline.create(dai.node.ImageManip)
cam.preview.link(copy_manip.inputImage)
copy_manip.setNumFramesPool(20)
copy_manip.setMaxOutputFrameSize(1072 * 1072 * 3)
copy_manip.out.link(face_det_manip.inputImage)
copy_manip.out.link(script.inputs['preview'])
print("Creating Head pose estimation NN")
headpose_manip = pipeline.create(dai.node.ImageManip)
headpose_manip.setWaitForConfigInput(True) # needed to maintain sync
headpose_manip.initialConfig.setResize(60, 60)
script.outputs['manip_cfg'].link(headpose_manip.inputConfig)
script.outputs['manip_img'].link(headpose_manip.inputImage)
headpose_nn = pipeline.create(dai.node.NeuralNetwork)
headpose_nn.setBlobPath(
blobconverter.from_zoo(name="head-pose-estimation-adas-0001",
shaves=6,
version=openvino_version))
headpose_manip.out.link(headpose_nn.input)
headpose_nn.out.link(script.inputs['headpose_in'])
headpose_nn.passthrough.link(script.inputs['headpose_pass'])
print("Creating face recognition ImageManip/NN")
face_rec_manip = pipeline.create(dai.node.ImageManip)
face_rec_manip.setWaitForConfigInput(True) # needed to maintain sync
face_rec_manip.initialConfig.setResize(112, 112)
script.outputs['manip2_cfg'].link(face_rec_manip.inputConfig)
script.outputs['manip2_img'].link(face_rec_manip.inputImage)
face_rec_cfg_out = pipeline.create(dai.node.XLinkOut)
face_rec_cfg_out.setStreamName('face_rec_cfg_out')
script.outputs['manip2_cfg'].link(face_rec_cfg_out.input)
# Only send metadata for the host-side sync
# pass2_out = pipeline.create(dai.node.XLinkOut)
# pass2_out.setStreamName('pass2')
# pass2_out.setMetadataOnly(True)
# script.outputs['manip2_img'].link(pass2_out.input)
face_rec_nn = pipeline.create(dai.node.NeuralNetwork)
# Removed from OMZ, so we can't use blobconverter for downloading, see here:
# https://github.com/openvinotoolkit/open_model_zoo/issues/2448#issuecomment-851435301
face_rec_nn.setBlobPath(
"models/face-recognition-mobilefacenet-arcface_2021.2_4shave.blob")
face_rec_manip.out.link(face_rec_nn.input)
if DISPLAY_FACE:
xout_face = pipeline.createXLinkOut()
xout_face.setStreamName('face')
face_rec_manip.out.link(xout_face.input)
arc_out = pipeline.create(dai.node.XLinkOut)
arc_out.setStreamName('arc_out')
face_rec_nn.out.link(arc_out.input)
return pipeline
labelMap = ["background", "person" ]
# Get argument first
parser = argparse.ArgumentParser()
parser.add_argument('-nn', '--nn', type=str, help=".blob path")
parser.add_argument('-vid', '--video', type=str, help="Path to video file to be used for inference (conflicts with -cam)")
parser.add_argument('-spi', '--spi', action='store_true', default=False, help="Send tracklets to the MCU via SPI")
parser.add_argument('-cam', '--camera', action="store_true", help="Use DepthAI RGB camera for inference (conflicts with -vid)")
parser.add_argument('-t', '--threshold', default=0.25, type=float,
help="Minimum distance the person has to move (across the x/y axis) to be considered a real movement")
args = parser.parse_args()
parentDir = Path(__file__).parent
videoPath = args.video or parentDir / Path('demo/example_01.mp4')
nnPath = args.nn or blobconverter.from_zoo(name="person-detection-retail-0013", shaves=7)
# Whether we want to use video from host or rgb camera
VIDEO = not args.camera
class TextHelper:
def __init__(self) -> None:
self.bg_color = (0, 0, 0)
self.color = (255, 255, 255)
self.text_type = cv2.FONT_HERSHEY_SIMPLEX
self.line_type = cv2.LINE_AA
def putText(self, frame, text, coords):
cv2.putText(frame, text, coords, self.text_type, 1, self.bg_color, 6, self.line_type)
cv2.putText(frame, text, coords, self.text_type, 1, self.color, 2, self.line_type)
# Start defining a pipeline
Blob taken from:
https://github.com/PINTO0309/PINTO_model_zoo/tree/main/151_object_detection_mobile_object_localizer
'''
# --------------- Arguments ---------------
parser = argparse.ArgumentParser()
parser.add_argument('-t',
'--threshold',
type=float,
help="Coonfidence threshold",
default=0.2)
args = parser.parse_args()
THRESHOLD = args.threshold
NN_PATH = blobconverter.from_zoo(name="mobile_object_localizer_192x192",
zoo_type="depthai")
NN_WIDTH = 192
NN_HEIGHT = 192
PREVIEW_WIDTH = 640
PREVIEW_HEIGHT = 360
# --------------- Methods ---------------
def plot_boxes(frame, boxes, colors, scores):
color_black = (0, 0, 0)
for i in range(boxes.shape[0]):
box = boxes[i]
y1 = (frame.shape[0] * box[0]).astype(int)
y2 = (frame.shape[0] * box[2]).astype(int)
x1 = (frame.shape[1] * box[1]).astype(int)
'''
# --------------- Arguments ---------------
parser = argparse.ArgumentParser()
parser.add_argument("-w",
"--width",
help="select model width for inference",
default=320,
type=float)
args = parser.parse_args()
# choose width and height based on model
if args.width == 320:
NN_WIDTH, NN_HEIGHT = 320, 240
NN_PATH = blobconverter.from_zoo(name="depth_estimation_mbnv2_240x320",
zoo_type="depthai")
else:
NN_WIDTH, NN_HEIGHT = 640, 480
NN_PATH = blobconverter.from_zoo(name="depth_estimation_mbnv2_480x640",
zoo_type="depthai")
# --------------- Pipeline ---------------
# Start defining a pipeline
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.VERSION_2021_4)
# Define a neural network
detection_nn = pipeline.createNeuralNetwork()
detection_nn.setBlobPath(str(NN_PATH))
detection_nn.setNumPoolFrames(4)
detection_nn.input.setBlocking(False)
# Send color frames to the host via XLink
cam_xout = p.create(dai.node.XLinkOut)
cam_xout.setStreamName("video")
cam.video.link(cam_xout.input)
# Crop 720x720 -> 300x300
face_det_manip = p.create(dai.node.ImageManip)
face_det_manip.initialConfig.setResize(300, 300)
cam.preview.link(face_det_manip.inputImage)
# NN that detects faces in the image
face_nn = p.create(dai.node.MobileNetDetectionNetwork)
face_nn.setConfidenceThreshold(0.3)
face_nn.setBlobPath(
blobconverter.from_zoo("face-detection-retail-0004",
shaves=6,
version=openvinoVersion))
face_det_manip.out.link(face_nn.input)
# Send ImageManipConfig to host so it can visualize the landmarks
config_xout = p.create(dai.node.XLinkOut)
config_xout.setStreamName("face_det")
face_nn.out.link(config_xout.input)
# Script node will take the output from the NN as an input, get the first bounding box
# and send ImageManipConfig to the manip_crop
image_manip_script = p.create(dai.node.Script)
face_nn.out.link(image_manip_script.inputs['nn_in'])
cam.preview.link(image_manip_script.inputs['frame'])
image_manip_script.setScript("""
import time
# Pipeline tells DepthAI what operations to perform when running - you define all of the resources used and flows here
pipeline = depthai.Pipeline()
# First, we want the Color camera as the output
cam_rgb = pipeline.createColorCamera()
cam_rgb.setPreviewSize(
300, 300
) # 300x300 will be the preview frame size, available as 'preview' output of the node
cam_rgb.setInterleaved(False)
# Next, we want a neural network that will produce the detections
detection_nn = pipeline.createMobileNetDetectionNetwork()
# Blob is the Neural Network file, compiled for MyriadX. It contains both the definition and weights of the model
# We're using a blobconverter tool to retreive the MobileNetSSD blob automatically from OpenVINO Model Zoo
detection_nn.setBlobPath(
str(blobconverter.from_zoo(name='mobilenet-ssd', shaves=6)))
# Next, we filter out the detections that are below a confidence threshold. Confidence can be anywhere between <0..1>
detection_nn.setConfidenceThreshold(0.5)
# Next, we link the camera 'preview' output to the neural network detection input, so that it can produce detections
cam_rgb.preview.link(detection_nn.input)
# XLinkOut is a "way out" from the device. Any data you want to transfer to host need to be send via XLink
xout_rgb = pipeline.createXLinkOut()
# For the rgb camera output, we want the XLink stream to be named "rgb"
xout_rgb.setStreamName("rgb")
# Linking camera preview to XLink input, so that the frames will be sent to host
cam_rgb.preview.link(xout_rgb.input)
# The same XLinkOut mechanism will be used to receive nn results
xout_nn = pipeline.createXLinkOut()
xout_nn.setStreamName("nn")
help='Show output')
parser.add_argument(
'-sp',
'--save_path',
type=str,
default='',
help='Path to save the output. If None output won\'t be saved')
parser.add_argument('-s',
'--sync',
action="store_true",
help="Sync RGB output with NN output",
default=False)
args = parser.parse_args()
if args.model is None:
args.model = str(blobconverter.from_zoo(name="mobilenet-ssd", shaves=7))
# Create pipeline
pipeline = dai.Pipeline()
# Define a neural network that will make predictions based on the source frames
nn = pipeline.createMobileNetDetectionNetwork()
nn.setConfidenceThreshold(0.5)
nn.setBlobPath(args.model)
nn.setNumInferenceThreads(2)
nn.input.setBlocking(False)
# Define a source for the neural network input
if args.video_path != '':
# Create XLinkIn object as conduit for sending input video file frames
# to the neural network
camRgb = pipeline.createColorCamera()
camRgb.setPreviewSize(NN_SIZE)
camRgb.setInterleaved(False)
camRgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_4_K)
camRgb.setIspScale(1,
3) # You don't need to downscale (4k -> 720P) video frames
xoutFrames = pipeline.createXLinkOut()
xoutFrames.setStreamName("frames")
camRgb.video.link(xoutFrames.input)
# Define a neural network that will make predictions based on the source frames
nn = pipeline.createMobileNetDetectionNetwork()
nn.setConfidenceThreshold(0.5)
nn.setBlobPath(blobconverter.from_zoo(name="mobilenet-ssd", shaves=6))
camRgb.preview.link(nn.input)
passthroughOut = pipeline.createXLinkOut()
passthroughOut.setStreamName("pass")
nn.passthrough.link(passthroughOut.input)
nnOut = pipeline.createXLinkOut()
nnOut.setStreamName("nn")
nn.out.link(nnOut.input)
# Connect to device and start pipeline
with dai.Device(pipeline) as device:
qFrames = device.getOutputQueue(name="frames")
qPass = device.getOutputQueue(name="pass")
qDet = device.getOutputQueue(name="nn")
VIDEO_SOURCE = args.video_path
#NN_PATH = args.nn_model
CONFIDENCE_THRESHOLD = args.confidence_thresh
IOU_THRESHOLD = args.iou_thresh
# resize input to smaller size for faster inference
NN_WIDTH = 320
NN_HEIGHT = 320
# set initial resize so the input is not too large
IR_WIDTH = 640
IR_HEIGHT = 360
# --------------- Get Blob ------------------
NN_PATH = blobconverter.from_zoo(name="yolop_320x320", zoo_type="depthai")
# --------------- Check input ---------------
vid_path = Path(VIDEO_SOURCE)
if not vid_path.is_file():
raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT),
VIDEO_SOURCE)
# --------------- Pipeline ---------------
# Start defining a pipeline
pipeline = dai.Pipeline()
pipeline.setOpenVINOVersion(version=dai.OpenVINO.VERSION_2021_4)
# Create Manip for image resizing and NN for count inference
manip = pipeline.createImageManip()
detection_nn = pipeline.createNeuralNetwork()
if not args.camera and not args.video:
raise RuntimeError(
"No source selected. Please use either \"-cam\" to use RGB camera as a source or \"-vid <path>\" to run on video"
)
debug = not args.no_debug
camera = not args.video
labels = class_names()
# Start defining a pipeline
pipeline = dai.Pipeline()
# NeuralNetwork
print("Creating Neural Network...")
detection_nn = pipeline.createNeuralNetwork()
detection_nn.setBlobPath(str(blobconverter.from_zoo(name="efficientnet-b0")))
if camera:
print("Creating Color Camera...")
cam_rgb = pipeline.createColorCamera()
cam_rgb.setPreviewSize(224, 224)
cam_rgb.setInterleaved(False)
cam_rgb.setResolution(
dai.ColorCameraProperties.SensorResolution.THE_1080_P)
cam_rgb.setBoardSocket(dai.CameraBoardSocket.RGB)
cam_rgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.RGB)
cam_xout = pipeline.createXLinkOut()
cam_xout.setStreamName("rgb")
cam_rgb.preview.link(cam_xout.input)
cam_rgb.preview.link(detection_nn.input)
import numpy as np
# Get argument first
# Start defining a pipeline
pipeline = dai.Pipeline()
# Define a source - color camera
cam_rgb = pipeline.createColorCamera()
cam_rgb.setPreviewSize(300, 300)
cam_rgb.setInterleaved(False)
# Define a neural network that will make predictions based on the source frames
detection_nn = pipeline.createMobileNetDetectionNetwork()
detection_nn.setConfidenceThreshold(0.5)
detection_nn.setBlobPath(str(blobconverter.from_zoo(name="mobilenet-ssd", shaves=13)))
cam_rgb.preview.link(detection_nn.input)
# Create outputs
xout_rgb = pipeline.createXLinkOut()
xout_rgb.setStreamName("rgb")
cam_rgb.preview.link(xout_rgb.input)
xout_nn = pipeline.createXLinkOut()
xout_nn.setStreamName("nn")
detection_nn.out.link(xout_nn.input)
# MobilenetSSD label texts
texts = ["background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow",
"diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
