def main(): camera_server = CameraServer.getInstance() camera_server.enableLogging() # TODO Use device addresses and sides here please cargo_camera = UsbCamera(name=CameraConfig.cargo_name, path=CameraConfig.cargo_dev_address) hatch_camera = UsbCamera(name=CameraConfig.hatch_name, path=CameraConfig.hatch_dev_address) front_camera = camera_server.startAutomaticCapture( name=CameraConfig.front_name, path=CameraConfig.front_dev_address) switching_server = camera_server.addSwitchedCamera("Switched") switching_server.setSource(hatch_camera) # Use networktables to switch the source # -> obviously, you can switch them however you'd like def _listener(source, key, value, isNew): if str(value) == "0": switching_server.setSource(hatch_camera) elif str(value) == "1": switching_server.setSource(cargo_camera) network_table = networktables.NetworkTables.getTable("/CameraPublisher") network_table.putString("Selected Camera", "0") network_table.addEntryListener(_listener, key="Selected Camera") camera_server.waitForever()
def startCamera(config): """Start running the camera.""" print("Starting camera '{}' on {}".format(config.name, config.path)) cs = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = cs.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) return cs, camera
def startCamera(config): """Start running the camera.""" print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) #server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) #camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) #if config.streamConfig is not None: #server.setConfigJson(json.dumps(config.streamConfig)) return camera
def main(): NetworkTables.initialize("10.68.51.2") LineDetect = DetectGreenTape() value = 0 sd = NetworkTables.getTable("SmartDashboard") ntinst = NetworkTablesInstance.getDefault() ntinst.startServer() inst = CameraServer.getInstance() camera1 = UsbCamera( "Camera1", "/dev/v4l/by-path/platform-3f980000.usb-usb-0:1.2:1.0-video-index0") camera2 = UsbCamera( "Camera2", "/dev/v4l/by-path/platform-3f980000.usb-usb-0:1.1.3:1.0-video-index0") camera1.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) camera2.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) usb1 = inst.startAutomaticCapture(camera=camera1) usb2 = inst.startAutomaticCapture(camera=camera2) usb1.setResolution(320, 240) usb2.setResolution(320, 240) cvSink = inst.getVideo(camera=camera2) img = np.zeros(shape=(240, 320, 3), dtype=np.uint8) while True: timestamp, img = cvSink.grabFrame(img) LineDetect.process(img) sd.putNumber('NbLinesDetectedNew', len(LineDetect.filter_lines_output)) Xmean1 = 0 Xmean2 = 0 Ymean1 = 0 Ymean2 = 0 angle = 0 nbLigne = len(LineDetect.filter_lines_output) for ligne in LineDetect.filter_lines_output: Xmean1 += ligne.x1 Xmean2 += ligne.x2 Ymean1 += ligne.y1 Ymean2 += ligne.y2 angle += ligne.angle() if nbLigne: Ymean1 /= nbLigne Ymean2 /= nbLigne Xmean1 /= nbLigne Xmean2 /= nbLigne angle /= nbLigne sd.putNumber('Xmean1', Xmean1) sd.putNumber('Xmean2', Xmean2) sd.putNumber('Ymean1', Ymean1) sd.putNumber('Ymean2', Ymean2) sd.putNumber('Angle', angle) time.sleep(0.1)
def startCamera(config): """Start running the camera.""" print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None: server.setConfigJson(json.dumps(config.streamConfig)) if config.name == "rPi Camera 1": camera.getProperty("contrast").set(0) camera.getProperty("brightness").set(50) camera.getProperty("saturation").set(50) return camera
def main(): img = np.zeros(shape=(480, 640, 3), dtype=np.uint8) cs = CameraServer.getInstance() cs.enableLogging() camera0 = cs.startAutomaticCapture(dev=0) camera1 = UsbCamera("cam1", 1) camera2 = UsbCamera("cam2", 2) # Get a CvSink. This will capture images from the camera cvSink = cs.getVideo() cvSink.setSource(camera0) # (optional) Setup a CvSource. This will send images back to the Dashboard smartDash = networktables.NetworkTables.getTable('SmartDashboard') def _listener(source, key, value, isNew): if value == 0: cvSink.setSource(camera0) elif value == 1: cvSink.setSource(camera1) elif value == 2: cvSink.setSource(camera2) smartDash.putNumber("Num", 0) outputStream = cs.putVideo("Out", 320, 240) while True: smartDash.addEntryListener(_listener, key="Num") time, img = cvSink.grabFrame(img) if time == 0: # Send the error. outputStream.notifyError(cvSink.getError()) # skip the rest of the current iteration continue # display a new image on the outputStream outputStream.putFrame(img)
def main(): cs = CameraServer.getInstance() cs.enableLogging() outputStream = CvSource('camera', VideoMode.PixelFormat.kMJPEG, int(640), int(480), int(15)) cs.addCamera(outputStream) server = cs.addServer(name='camera', port=int(5801)) server.setSource(outputStream) camera = UsbCamera( "cam1", '/dev/v4l/by-id/usb-HD_Camera_Manufacturer_USB_2.0_Camera-video-index0' ) # Capture from the first USB Camera on the system cs.startAutomaticCapture(camera=camera) camera.setResolution(640, 480) # Get a CvSink. This will capture images from the camera cvSink = cs.getVideo(camera=camera) # Allocating new images is very expensive, always try to preallocate img = np.zeros(shape=(480, 640, 3), dtype=np.uint8) while True: # Tell the CvSink to grab a frame from the camera and put it # in the source image. If there is an error notify the output. time, img = cvSink.grabFrame(img) if time == 0: # Send the output the error. outputStream.notifyError(cvSink.getError()) # skip the rest of the current iteration continue # # Insert your image processing logic here! # cv2.imshow("stream", img) # (optional) send some image back to the dashboard outputStream.putFrame(img)
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None: server.setConfigJson(json.dumps(config.streamConfig)) cvSink = inst.getVideo() if config.name == "PS3 Eyecam": cvSrc = inst.putVideo( config.name + " Vision", 320, 240) #Change to get values from config file 160,120 else: cvSrc = inst.putVideo( config.name + " Vision", 160, 120) #Change to get values from config file 160,120 print(config.height) return camera, cvSink, cvSrc
def startCamera(): print("Starting camera rPi on /dev/video0") cs = CameraServer.getInstance() camera = UsbCamera("rPi Camera", "/dev/video0") #camera.setVideoMode(VideoMode.PixelFormat.kMJPEG, 320, 240, 60) camera.setVideoMode(VideoMode.PixelFormat.kYUYV, 320, 240, 60) #camera = cs.startAutomaticCapture(name="rPi Camera", path="/dev/video0") server = cs.startAutomaticCapture(camera=camera, return_server=True) server.setCompression(25) server.setFPS(45) #camera.setResolution(320,240) #camera.setConfigJson(json.dumps(config.config)) camera.getProperty('color_effects').set(3) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) return cs, camera
def main(): cs = CameraServer.getInstance() cs.enableLogging() usb0 = UsbCamera("Camera 0", 0) usb1 = UsbCamera("Camera 1", 1) server = cs.addSwitchedCamera("Switched") server.setSource(usb0) # Use networktables to switch the source # -> obviously, you can switch them however you'd like def _listener(source, key, value, isNew): if str(value) == "0": server.setSource(usb0) elif str(value) == "1": server.setSource(usb1) table = networktables.NetworkTables.getTable("/CameraPublisher") table.putString("selected", "0") table.addEntryListener(_listener, key="selected") cs.waitForever()
def startCamera(config): """Start running the camera.""" print("Starting camera '{}' on {}".format(config.name, config.path)) camera = UsbCamera(config.name, config.path) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) return camera
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) # camera.setConfigJson(json.dumps(config.config)) camera.setConfigJson(config_json) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) inst.addCamera(camera) return inst, camera
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) # camera.setConfigJson(json.dumps(config.config)) camera.setConfigJson(config_json) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) return inst, camera, server
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionmodeategy(VideoSource.Connectionmodeategy.kKeepOpen) if config.modeeamConfig is not None: server.setConfigJson(json.dumps(config.modeeamConfig)) return camera
def startDriveCamera(self, config): """ Start running a drive camera. """ self.logger.logMessage("Starting camera '{}' on {}".format( config.name, config.path)) camera = UsbCamera("Drive", config.path) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) return camera
def main(): NetworkTables.initialize("10.68.51.2") capture = cv2.VideoCapture("/dev/v4l/by-path/platform-3f980000.usb-usb-0:1.1.3:1.0-video-index0") LineDetect = DetectGreenTape() value = 0 sd = NetworkTables.getTable("SmartDashboard") ntinst = NetworkTablesInstance.getDefault() ntinst.startServer() inst = CameraServer.getInstance() camera = UsbCamera("Camera1","/dev/v4l/by-path/platform-3f980000.usb-usb-0:1.2:1.0-video-index0" ) server = inst.startAutomaticCapture(camera=camera, return_server=True) atexit.register(FonctionSortie, capture, server, camera) while True: ret, frame = capture.read() if ret: LineDetect.process(frame) sd.putNumber('NbLinesDEtected',len(LineDetect.filter_lines_output))
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None: server.setConfigJson(json.dumps(config.streamConfig)) cvSink = inst.getVideo(name=config.name) cvSrc = inst.putVideo(config.name + " Vision", config.height, config.width) return camera, cvSink, cvSrc
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) # makes a server port for the camera inst = CameraServer.getInstance() # makes a connection to the camera file camera = UsbCamera(config.name, config.path) # connects the server to the camera and makes the camera send images through the server server = inst.startAutomaticCapture(camera=camera, return_server=True) # configures the camera to the specified dictionary camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None: server.setConfigJson(json.dumps(config.streamConfig)) return camera
def startCameras(): global cs for config in cameraConfigs: print("Starting camera '{}' on {}".format(config.name, config.path)) camera = UsbCamera(config.name, config.path) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.name == "driver_cam" and config.streamConfig is not None: print("Starting automatic capture for camera '{}'".format( config.name)) server = cs.startAutomaticCapture(camera=camera, return_server=True) server.setConfigJson(json.dumps(config.streamConfig)) cameras.append(camera)
def startCamera(config): """Start running the camera.""" print("Starting camera '{}' on {}".format(config.name, config.path)) cs = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) #camera.setExposureManual(5) cv_sink = cs.getVideo(camera=camera) output_stream = cs.putVideo('output_' + config.name, config.width, config.height) img = np.zeros(shape=(config.height, config.width, 3), dtype=np.uint8) input_output.append((cv_sink, output_stream, img)) #server = cs.startAutomaticCapture(return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) #if config.streamConfig is not None: #server.setConfigJson(json.dumps(config.streamConfig)) return camera
def startCamera(config): """Start running the camera.""" print("Starting camera '{}' on {}".format(config.name, config.path)) global inst inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) # if not isSinkMade: # cvSink = inst.getVideo() # isSinkMade = True camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None: server.setConfigJson(json.dumps(config.streamConfig)) print("Started camera '{}' on {}".format(config.name, config.path)) return camera
def start_camera(): inst = CameraServer.getInstance() camera = UsbCamera('Hatch Panels', '/dev/video0') camera.setConfigJson(picamera_config_json) # with open("cam.json", encoding='utf-8') as cam_config: # camera.setConfigJson(json.dumps(cam_config.read())) # camera.setResolution(VERTICAL_RES, HORIZONTAL_RES) # camera.setFPS(FPS) # camera.setBrightness(10) # camera.setConfigJson(""" # { # "fps": """ + str(FPS) + """, # "height": """ + str(HORIZONTAL_RES) + """, # "pixel format": "mjpeg", # "properties": [ # { # "name": "brightness", # "value": 0 # }, # { # "name": "contrast", # "value": 100 # }, # { # "name": "saturation", # "value": 100 # }, # { # "name": "color_effects", # "value": 3 # } # ], # "width": """ + str(VERTICAL_RES) + """ # } # """) # # inst.startAutomaticCapture(camera=camera) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) return inst, camera
def startCamera(config): print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = None server = None #ADDED CODE: handle pixy camera capture by creating a cvsource, otherwise normal if config.pixy: #if the camera is a pixy, get a CvSource to put the generated images in global pixy_source pixy_source = inst.putVideo("Pixy", 51, 51) else: #if the camera is not a pixy, automatically capture it camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None and config.pixy is False: server.setConfigJson(json.dumps(config.streamConfig)) return camera
def startCamera(config): """Start running the camera.""" global cvSink global outputStream print("Starting camera '{}' on {}".format(config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) server = inst.startAutomaticCapture(camera=camera, return_server=True) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) if config.streamConfig is not None: server.setConfigJson(json.dumps(config.streamConfig)) # Get a CvSink. This will capture images from the camera cvSink = inst.getVideo() # (optional) Setup a CvSource. This will send images back to the Dashboard outputStream = inst.putVideo("image", width, height) return camera
def startVisionCamera(self, config): """ Start running the vision camera. """ self.logger.logMessage("Starting camera '{}' on {}".format( config.name, config.path)) inst = CameraServer.getInstance() camera = UsbCamera(config.name, config.path) camera.setConfigJson(json.dumps(config.config)) camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen) # Start automatic capture stream if (Constants.ENABLE_RAW_STREAM): self.logger.logMessage("Starting Raw Output Stream...") camera_server = inst.startAutomaticCapture(camera=camera, return_server=True) if config.stream_config is not None: camera_server.setConfigJson(json.dumps(config.stream_config)) return camera
solid = 100 * area / cv2.contourArea(hull) if (solid < solidity[0] or solid > solidity[1]): continue if (len(contour) < min_vertex_count or len(contour) > max_vertex_count): continue ratio = (float)(w) / h if (ratio < min_ratio or ratio > max_ratio): continue output.append(contour) return output gLine = Example() camera = UsbCamera("CammyBoi", 0) camera.setExposureManual(10) #camera.setConfigJson(json.dumps(json.load(open(configFile, "rt", encoding="utf-8")))) vidSink = CvSink("Camera") vidSink.setSource(camera) vidSource = CvSource("Processed", VideoMode.PixelFormat.kMJPEG, 640, 480, 30) networkStream = MjpegServer("Stream", 1181) networkStream.setSource(vidSource) img = np.zeros(shape=(480, 640, 3), dtype=np.uint8) while(True): ret, src = vidSink.grabFrame(img) startTime = time.time() gLine.process(src)
if not readConfig(): sys.exit(1) # start NetworkTables to send to smartDashboard ntinst = NetworkTablesInstance.getDefault() print("Setting up NetworkTables client for team {}".format(team)) ntinst.startClientTeam(7539) SmartDashBoardValues = ntinst.getTable('SmartDashboard') #Start camera print("Connecting to camera") cs = CameraServer.getInstance() cs.enableLogging() Camera = UsbCamera('Cam 0', 0) Camera.setExposureManual(5) Camera.setResolution(160, 120) cs.addCamera(Camera) print("connected") CvSink = cs.getVideo() outputStream = cs.putVideo("Processed Frames", 160, 120) #buffer to store img data img = np.zeros(shape=(160, 120, 3), dtype=np.uint8) # loop forever while True: GotFrame, img = CvSink.grabFrame(img)
def main(): cs = CameraServer.getInstance() cs.enableLogging() outputStreamTarget = cs.putVideo("targetImage", imageResolutionSend[0], imageResolutionSend[1]) outputStreamTargetBinary = cs.putVideo("targetImageBinary", imageResolutionSend[0], imageResolutionSend[1]) outputStreamBall = cs.putVideo("ballImage", imageResolutionSend[0], imageResolutionSend[1]) # outputStreamBallBinary = cs.putVideo("ballImageBinary", imageResolutionSend[0], imageResolutionSend[1]) targetImage = np.zeros(shape=(imageResolutionRasp[1], imageResolutionRasp[0], 3), dtype=np.uint8) ballImage = np.zeros(shape=(imageResolutionRasp[1], imageResolutionRasp[0], 3), dtype=np.uint8) availableTargetCamera = targetCameraAddress in os.listdir("/dev") availableBallCamera = ballCameraAddress in os.listdir("/dev") if availableTargetCamera: cameraTarget = UsbCamera("Camera Target", "/dev/" + targetCameraAddress) cameraTarget.setResolution(imageResolutionRasp[0], imageResolutionRasp[1]) cameraTarget.setBrightness(brightnessTarget) cameraTarget.setExposureManual(exposureTarget) cs.addCamera(cameraTarget) cvSinkTarget = cs.getVideo(name="Camera Target") cvSinkTarget.setSource(cameraTarget) if availableBallCamera: cameraBall = UsbCamera("Camera Ball", "/dev/" + ballCameraAddress) cameraBall.setResolution(imageResolutionRasp[0], imageResolutionRasp[1]) cameraBall.setBrightness(brightnessBall) cameraBall.setExposureManual(exposureBall) cs.addCamera(cameraBall) cvSinkBall = cs.getVideo(name="Camera Ball") cvSinkBall.setSource(cameraBall) counter = 0 while True: if availableTargetCamera: availableTargetCamera = targetCameraAddress in os.listdir("/dev") if availableBallCamera: availableBallCamera = ballCameraAddress in os.listdir("/dev") counter += 1 textOutput = "" if calibration: getHSVBallParameters() getHSVTargetParameters() getCameraTargetParameters() getCameraBallParameters() getTargetDistanceParameters() if availableTargetCamera: t, targetImage = cvSinkTarget.grabFrame(targetImage) available, targetImage, binaryTargetImage, targetXPos, targetYPos = findTarget(targetImage) distance = calculateDistance(targetYPos) horizontalAngle = getHorizontalAngle(targetXPos, imageResolutionRasp) launcherAngle = getLauncherAngle(distance) if distance > 95 and distance < 240: cv2.rectangle(targetImage, (20, 20), (100, 100), (0, 255, 0), -1) netTableTargetAvailable.setBoolean(available) netTableTargetDistance.setDouble(distance) netTableTargetHorizontalAngle.setDouble(horizontalAngle) netTableTargetLauncherAngle.setDouble(launcherAngle) netTableTargetXPos.setDouble(targetXPos) netTableTargetYPos.setDouble(targetYPos) smallerBinaryTargetImage = cv2.resize(binaryTargetImage, (imageResolutionSend[0], imageResolutionSend[1])) smallerTargetImage = cv2.resize(targetImage, (imageResolutionSend[0], imageResolutionSend[1])) outputStreamTargetBinary.putFrame(smallerBinaryTargetImage) outputStreamTarget.putFrame(smallerTargetImage) textOutput += "Distance: {} horizontalAngle: {} launcherAngle: {} targetYPos: {}\n".format(distance, horizontalAngle, launcherAngle, targetYPos) else: textOutput += "Target Camera disabled\n" if availableBallCamera: t, ballImage = cvSinkBall.grabFrame(ballImage) # ballImage, binaryBallImage, ballXPos, ballYPos = findBall(ballImage) # angle = getHorizontalAngle(ballXPos, imageResolutionRasp) # netTableBallXPos.setDouble(ballXPos) # netTableBallYPos.setDouble(ballYPos) # netTableBallAngle.setDouble(angle) # smallerBinaryBallImage = cv2.resize(binaryBallImage, (imageResolutionSend[0], imageResolutionSend[1])) smallerBallImage = cv2.resize(ballImage, (imageResolutionSend[0], imageResolutionSend[1])) # outputStreamBallBinary.putFrame(smallerBinaryBallImage) outputStreamBall.putFrame(smallerBallImage) # textOutput += "ballXPos: {} ballYPos: {}\n".format(ballXPos, ballYPos) else: textOutput += "Ball Camera disabled\n" if counter % 10 == 0: print(textOutput)
ip = '10.30.6.2' NetworkTables.initialize(server=ip) lower_green = np.array([0, 255, 110]) #137 240 135 - HSV, 0,90,90 - RGB upper_green = np.array([80, 255, 200]) #143 255 148 - HSV, 86,255,255 - RGB camWidth = 320 camHeight = 240 center_x = camWidth * .5 margin = 20 cs = CameraServer.getInstance() cs.enableLogging() cam1 = UsbCamera("cam1", 0) cam2 = UsbCamera("cam2", 1) cam1.setResolution(camWidth, camHeight) cam2.setResolution(camWidth, camHeight) cam1.setExposureManual(8) cam2.setExposureManual(8) cvSink = cs.getVideo(camera=cam1) outputStream = cs.putVideo("Cam1", camWidth, camHeight) frame = np.zeros(shape=(camHeight, camWidth, 3), dtype=np.uint8)
ntinst = NetworkTablesInstance.getDefault() if server: print("Setting up NetworkTables server") ntinst.startServer() else: print("Setting up NetworkTables client for team {}".format(team)) ntinst.startClientTeam(team) sd = ntinst.getTable("Shuffleboard") img0 = np.zeros(shape=(image_height, image_width, 3), dtype=np.uint8) img1 = np.zeros(shape=(image_height, image_width, 3), dtype=np.uint8) portPath = "/dev/video0" cellPath = "/dev/video2" cameraPort = UsbCamera("PortCam", portPath) cameraCell = UsbCamera("CellCam", cellPath) inst = CameraServer.getInstance() inst.startAutomaticCapture(camera=cameraPort) inst.startAutomaticCapture(camera=cameraCell) cvSink0 = inst.getVideo(camera=cameraPort) cvSink1 = inst.getVideo(camera=cameraCell) #outputStream0 = inst.putVideo("PortStream", (image_width), (image_height)) outputStream1 = inst.putVideo("CellStream", (image_width), (image_height)) # loop forever while True: timestamp, img0 = cvSink0.grabFrame(img0)