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))
return inst
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 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()
cvSrc = inst.putVideo(config.name + " Vision", 160, 120) #Change to get values from config file
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))
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))
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):
"""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
