def v4l2_video_capture():
frame = Frame('/dev/video0')
frame_data = frame.get_frame()
while True:
q.put(frame_data)
q.get() if q.qsize() > 1 else time.sleep(0.01)
from pyv4l2.frame import Frame
from pyv4l2.control import Control
frame = Frame('/dev/video0')
frame_data = frame.get_frame()
control = Control("/dev/video0")
print(control.get_controls())
print(control.get_control_value(9963776))
print(control.set_control_value(9963776, 8))
def record(self):
""" Start recording """
self.frame = Frame(self.device_name)
class pyv4l2_reader:
""" This class was created to look as similar to the openCV features used in Howdy as possible for overall code cleanliness. """
# Init
def __init__(self, device_name, device_format):
self.device_name = device_name
self.device_format = device_format
self.height = 0
self.width = 0
self.probe()
self.frame = ""
def set(self, prop, setting):
""" Setter method for height and width """
if prop == CAP_PROP_FRAME_WIDTH:
self.width = setting
elif prop == CAP_PROP_FRAME_HEIGHT:
self.height = setting
def get(self, prop):
""" Getter method for height and width """
if prop == CAP_PROP_FRAME_WIDTH:
return self.width
elif prop == CAP_PROP_FRAME_HEIGHT:
return self.height
def probe(self):
""" Probe the video device to get height and width info """
vd = open(self.device_name, 'r')
fmt = v4l2.v4l2_format()
fmt.type = v4l2.V4L2_BUF_TYPE_VIDEO_CAPTURE
ret = fcntl.ioctl(vd, v4l2.VIDIOC_G_FMT, fmt)
vd.close()
if ret == 0:
height = fmt.fmt.pix.height
width = fmt.fmt.pix.width
else:
# Could not determine the resolution from ioctl call. Reverting to slower ffmpeg.probe() method
import ffmpeg
probe = ffmpeg.probe(self.device_name)
height = int(probe['streams'][0]['height'])
width = int(probe['streams'][0]['width'])
if self.get(CAP_PROP_FRAME_HEIGHT) == 0:
self.set(CAP_PROP_FRAME_HEIGHT, int(height))
if self.get(CAP_PROP_FRAME_WIDTH) == 0:
self.set(CAP_PROP_FRAME_WIDTH, int(width))
def record(self):
""" Start recording """
self.frame = Frame(self.device_name)
def grab(self):
""" Read a sigle frame from the IR camera. """
self.read()
def read(self):
""" Read a sigle frame from the IR camera. """
if not self.frame:
self.record()
# Grab a raw frame from the camera
frame_data = self.frame.get_frame()
# Convert the raw frame_date to a numpy array
img = (numpy.frombuffer(frame_data, numpy.uint8))
# Convert the numpy array to a proper grayscale image array
img_bgr = cvtColor(img, COLOR_GRAY2BGR)
# Convert the grayscale image array into a proper RGB style numpy array
img2 = (numpy.frombuffer(img_bgr, numpy.uint8).reshape([352, 352, 3]))
# Return a single frame of video
return 0, img2
def release(self):
""" Empty our array. If we had a hold on the camera, we would give it back here. """
self.video = ()
self.num_frames_read = 0
if self.frame:
self.frame.close()
parser.add_argument('--width', type=int, default=720)
parser.add_argument('--height', type=int, default=576)
parser.add_argument('--scale', type=float, default=1.)
parser.add_argument('--visdom-server', type=str, default='http://localhost')
parser.add_argument('--visdom', action='store_true')
parser.add_argument('--device', type=str, default='/dev/video0')
args = parser.parse_args()
w = int(args.width // args.scale)
h = int(args.height // args.scale)
os.system('v4l2-ctl -d {device} --set-fmt-video width={w},height={h}'.format(
device=args.device, w=w, h=h))
frame = Frame(args.device)
if args.visdom:
import visdom
vis = visdom.Visdom(server=args.visdom_server)
pi = pigpio.pi()
if not pi.connected:
print("could not connect spi")
exit()
spi = pi.spi_open(0, 750000, 0)
SYNC_PIN = 24
pi.set_mode(SYNC_PIN, pigpio.INPUT)
NUM_LEDS_H = 16
NUM_LEDS_V = 24
def get_picture(self, idx):
frame = Frame('/dev/video%d' % idx)
frame_data = frame.get_frame()
print frame_data
* Also, set your video device (default /dev/video0)
* Hit h and l to adjust the threshold multiplier
(Lower (h) gives more frequent updates
* While it waits for some initial frames, it otherwise
begins right away, so it doesn't have a proper average for the
brightness peaks. The end result is you get some images
showing quickly, then they should reduce in frequency.
''')
avg_over=5 # Number of frames for averaging, to remove noise.
# This same count is used for figuring out the
# threshold of peak brightness. (I currently keep
# those entire images, but I could just keep their
# sums for detecting peaks. Should fix that later.)
frame = Frame(vdev)
pltimg = None
plt.ion()
#def __init__(self, dims=None, count=None, dtype=np.uint8):
imgsbuf = ImageBuf(dims=(ih,iw,3), count=avg_over)
diffbuf = ImageBuf(dims=(ih,iw,3), count=avg_over)
framecount=0
anomalycount=0
#thresh = 217000
tmult = 1.15
while True:
imgd = frame.get_frame()
framecount += 1
img = np.frombuffer(imgd, dtype=np.uint8)
img = img.reshape((ih,iw,3))
imgsbuf.add(img)