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(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)
#server.setResolution(640, 360)
camera.setConfigJson(json.dumps(config.config))
if config.path == "/dev/video0":
camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen)
#camera.setExposureManual(1)
#camera.setWhiteBalanceManual(50)
#os.system("v4l2-ctl -d /dev/video0 -c auto_exposure=1")
#os.system("v4l2-ctl -d /dev/video0 -c exposure_time_absolute=100")
#os.system("")
camera.getProperty("auto_exposure").set(1)
camera.getProperty("exposure_time_absolute").set(50)
camera.getProperty("contrast").set(100)
#camera.getProperty("white_balance_temperature_auto").set(0)
#for prop in camera.enumerateProperties():
#print(prop.getName())
if config.streamConfig is not None:
server.setConfigJson(json.dumps(config.streamConfig))
return camera
def start_camera():
inst = CameraServer.getInstance()
camera = UsbCamera('Hatch Panels', '/dev/video0')
# 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": 40
}
],
"width": """ + str(VERTICAL_RES) + """
}
""")
camera.setConnectionStrategy(VideoSource.ConnectionStrategy.kKeepOpen)
return inst, camera
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):
"""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):
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))
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 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 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))
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 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 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 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):
"""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 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 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
smart_dashboard.getEntry('Vision/Threshhold/Lower/hue').addListener(
set_threshhold_value('lower', 'hue'),
ntcore.constants.NT_NOTIFY_UPDATE)
smart_dashboard.getEntry(
'Vision/Threshhold/Lower/saturation').addListener(
set_threshhold_value('lower', 'saturation'),
ntcore.constants.NT_NOTIFY_UPDATE)
smart_dashboard.getEntry('Vision/Threshhold/Lower/value').addListener(
set_threshhold_value('lower', 'value'),
ntcore.constants.NT_NOTIFY_UPDATE)
# Find primary and secondary cameras
cameras = []
for config in camera_configs:
camera = UsbCamera(config.name, config.path)
camera.setConfigJson(json.dumps(config.config))
cvsink = CvSink('cvsink: ' + config.name)
cvsink.setSource(camera)
cvsink.setEnabled(False) # disable frame fetching by default
# Add 3 things to the list of cameras: the camera object itself,
# the cvsink object, and the camera configuration dictionary.
# The first two all the only ones actually needed. Two stream
# the camera you can use in server.setsource(cam), and the
# cvsink is used to enable fetching frames. config.config is
# only used to access configuration information like the name
# and resolution.
cameras.append((camera, cvsink, config.config))
vision_camera = None