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)
