def __init__(self,
name='Dual Webcam',
camera1=1,
camera2=3,
x_resolution=720,
y_resolution=480,
timeout=10):
self.name = name
self.cam_left = Webcam('cam1', camera1, x_resolution, y_resolution)
self.cam_right = Webcam('cam2', camera2, x_resolution, y_resolution)
self.tryTimeOut = 10
def __init__(self):
# initialise webcams
self.webcam_one = Webcam(0)
self.webcam_two = Webcam(1)
# initialise config
self.config_provider = ConfigProvider()
# initialise features
self.features = Features(self.config_provider)
# initialise texture
self.texture_background = None
def __init__(self,
height,
width,
n_inputs,
n_hidden,
n_outputs,
non_linearity,
device,
webcam=False):
self.height = height
self.width = width
self.n_inputs = n_inputs
self.n_hidden = n_hidden
self.n_outputs = n_outputs
self.non_linearity = non_linearity
self.device = device
self.network = Network(n_inputs, n_hidden, n_outputs, non_linearity)
self.network.to(device)
self.network_new = Network(n_inputs, n_hidden, n_outputs,
non_linearity)
self.network_new.to(device)
self.sound = Sound()
self.visualisation_input = self._create_visualisation_tensor()
if webcam:
self.webcam = Webcam()
self.webcam.start()
def __init__(self, btAddr):
# init needed values
self.btAddr = btAddr
self.player = None
self.texture_background = None
self.set_ids = []
self.set_players = []
self.players = []
self.calc_values()
# initialise webcam and start thread
self.webcam = Webcam()
self.webcam.start()
# connect wiimote and create model
wiiModel = WiiModel.WiiModel(self.btAddr)
# init openGl, Qt and Wiimote
self.initOpenGL()
self.initGUI()
# run wiimote-connection-loop
thread = threading.Thread(target=wiiModel.wiimoteLoop, args=(self.mainWindow, self.cursor))
thread.start()
# run opengl and camera in a thread
thread = threading.Thread(target=glutMainLoop, args=())
thread.start()
# run Qt
self.app.exec_()
def _create_cameras(self):
cameras = []
for camera_number in range(self.config_provider.number_of_cameras):
cameras.append(Webcam(camera_number))
return cameras
def __init__(self):
self.cam = Webcam()
self.textura_cam = 0
self.ancho = 640
self.alto = 480
self.obj = None
self.x = -5
self.y = 0.1
def __init__(self):
# initialise webcam and start thread
self.webcam = Webcam()
self.webcam.start()
# textures
self.texture_background = None
self.texture_cube = None
def __init__(self):
self.MU = Webcam()
self.img_intensity = []
self.img_time = []
self.MU.start()
self.filtered_average = []
self.MU.register_callback(self._average_intensity, 1)
self.img = []
self.euclidean_dist = None
def __init__(self):
self.webcam = Webcam()
self.webcam.start()
self.glyphs = Glyphs()
self.cone = None
self.sphere = None
self.texture_background = None
def __init__(self):
self.w = Webcam()
self.start = self.w.start()
self.im = self.w.grab_image()
self.w.register_callback(self.average_intensity, 1)
self.avg_intensity = []
self.images = []
self.filtered = []
self.f, self.ax = plt.subplots(1, 1)
def __init__(self):
self.webcam = Webcam()
self.webcam.start()
self.detection = Detection()
self.x_axis = 0.0
self.y_axis = 0.0
self.z_axis = 0.0
self.z_pos = -7.0
def __init__(self):
self.webcam = Webcam()
self.webcam.start()
self.detection = Detection()
self.x_axis = 0.0
self.z_axis = 0.0
self.show_cube = False
self.texture_background = None
self.texture_cube = None
def __init__(self):
self.webcam = Webcam()
self.buffer_size = 40
self.fps = 0
self.times = []
self.t0 = time.time()
self.data_buffer = []
#self.vidmag_frames = []
self.frame_out = np.zeros((10, 10, 3), np.uint8)
self.webcam.start()
print("init")
def main():
webcam = Webcam()
webcam.start()
mnp = MarkNplay()
while True:
image = webcam.get_current_frame()
mnp.screen_thread(image)
cv2.imshow('AR Book Reader', image)
cv2.waitKey(10)
def __init__(self):
# initialise webcam and start thread
self.webcam = Webcam()
self.webcam.start()
# initialise glyphs
self.glyphs = Glyphs()
# initialise shapes
self.cone = None
self.sphere = None
# self.hp = HP()
# initialise texture
self.texture_background = None
def __init__(self):
super(GUI, self).__init__()
self.initUI()
self.webcam = Webcam()
#self.video = Video()
self.input = self.webcam
self.dirname = ""
print("Input: webcam")
self.statusBar.showMessage("Input: webcam", 5000)
self.process = Process()
self.status = False
self.frame = np.zeros((10, 10, 3), np.uint8)
#self.plot = np.zeros((10,10,3),np.uint8)
self.bpm = 0
def __init__(self):
#initialize the webcam
self.camera = Webcam()
#initialize optical debug mode
self.opticalDebugMode = False
#initialize the video window
cv2.namedWindow(WIN_NAME, cv2.CV_WINDOW_AUTOSIZE)
#start collecting frames for processing
self.init_frames()
#initialize Algorithm instance
self.alg = Algorithm()
def __init__(self):
self._debug = conf['debug'] or False
self._cv_debug = conf['cv_debug'] or False
self.webcam = Webcam()
self.tracker = Tracker()
self.detector = FaceClassifier()
self.last_tick = cv.getTickCount()
self.got_face = False
self.sample_stream = self.webcam.as_observable() \
.sample(1000) \
.do_action(lambda f: self._debug and print('sampled at {}'.format(datetime.now()))) \
.map(self.detect) \
.publish() \
.auto_connect()
def __init__(self):
# sigint interrupt initialize
signal.signal(signal.SIGINT, self.signal_handler)
# initialize webcam
self.webcam = Webcam()
self.webcam.start()
self.x_axis = 0.0
self.y_axis = 0.0
self.z_axis = 0.0
self.z_pos = -7.0
self.win = 0
self.texture_background = None
self.texture_teapot = None
def take_imgs(chessboard_size=(11,7), kSaveImageDeltaTime=1):
sys.path.append("../")
os.makedirs("./calib_images", exist_ok=True)
camera_num = 0
if len(sys.argv) == 2:
camera_num = int(sys.argv[1])
print('opening camera: ', camera_num)
webcam = Webcam(camera_num)
webcam.start()
lastSaveTime = time.time()
while True:
# get image from webcam
image = webcam.get_current_frame()
if image is not None:
# check if pattern found
ret, corners = cv2.findChessboardCorners(cv2.cvtColor(image,cv2.COLOR_BGR2GRAY), chessboard_size, None)
if ret == True:
print('found chessboard')
# save image
filename = datetime.now().strftime('%Y%m%d_%Hh%Mm%Ss%f') + '.bmp'
image_path="./calib_images/" + filename
elapsedTimeSinceLastSave = time.time() - lastSaveTime
do_save = elapsedTimeSinceLastSave > kSaveImageDeltaTime
print(elapsedTimeSinceLastSave, kSaveImageDeltaTime)
if do_save:
lastSaveTime = time.time()
print('saving file ', image_path)
cv2.imwrite(image_path, image)
# draw the corners
image = cv2.drawChessboardCorners(image, chessboard_size, corners, ret)
cv2.imshow('camera', image)
else:
pass
#print('empty image')
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def __init__(self):
if os.path.exists("data.json"):
os.remove("data.json")
super(GUI, self).__init__()
self.initUI()
self.webcam = Webcam()
self.video = Video()
self.input = self.webcam
self.dirname = ""
print("Input: webcam")
self.statusBar.showMessage("Input: webcam", 5000)
self.btnOpen.setEnabled(False)
self.process = Process()
self.status = False
self.frame = np.zeros((10, 10, 3), np.uint8)
#self.plot = np.zeros((10,10,3),np.uint8)
self.bpm = 0
def __init__(self, *args, **kwargs):
super(Studio, self).__init__(*args, **kwargs)
self.setupUi(self)
# Device
self.device_default = 0
self.device = self.device_default
# Webcam
self.webcam = Webcam()
# Image
self.image_dir = 'outputs'
self.image_ext = 'jpg'
self.num_images_max_default = 10
self.num_images_max = self.num_images_max_default
self.num_images = 0
self.saved_width_default = 416 # In pixel
self.saved_height_default = 416
self.saved_width = self.saved_width_default
self.saved_height = self.saved_height_default
self.flip_image = False
self.cb_flip_image.stateChanged.connect(self.change_flip_image)
# Filename prefix
self.filename_prefix = 'class_memo'
# Recording flag
self.is_recording = False
# Timer
self.timer_is_on = False
self.timer_duration = 500 # msec
self.timer = QTimer(self)
self.timer.timeout.connect(self.process_image)
# Plot min/max
self.plot_min = 0.0
self.plot_max = -1.0
# Initialize
self.initialize()
def __init__(self):
# initialise config
self.config_provider = ConfigProvider()
# initialise robots
self.rocky_robot = RockyRobot()
self.sporty_robot = SportyRobot()
# initialise webcam
self.webcam = Webcam()
# initialise markers
self.markers = Markers()
self.markers_cache = None
# initialise features
self.features = Features(self.config_provider)
# initialise texture
self.texture_background = None
def __start_record_clicked(self, widget):
container_remove_all(self.under_camera_box)
self.under_camera_box.pack_start(self.keep_few_minutes)
self.webcam_align = gtk.Alignment(0, 0.5, 0, 0)
self.webcam_align.set_padding(5, 5, 5, 5)
if not hasattr(self.account_setting, "record_webcam"):
self.account_setting.record_webcam = Webcam()
self.account_setting.record_webcam.set_size_request(
WEBCAM_SIZE, min(WEBCAM_SIZE, 240))
self.account_setting.record_webcam.create_video_pipeline(320, 240)
self.webcam_align.add(self.account_setting.record_webcam)
container_remove_all(self.camera_box)
self.camera_box.add(self.webcam_align)
self.account_setting.record_webcam.play()
gobject.timeout_add(2000, self.__do_save_photo, 0)
gobject.timeout_add(2500, self.__do_save_photo, 1)
gobject.timeout_add(3000, self.__do_save_photo, 2)
gobject.timeout_add(3500, self.__do_save_photo, 3)
gobject.timeout_add(4000, self.__do_action)
def __init__(self):
# initialise webcam and start thread
self.webcam = Webcam()
self.webcam.start()
self.find = fp()
self.find.set_img('sample.jpg')
self.hei, self.wid = self.webcam.get_frame_shape()[:2]
# initialise cube
# self.d_obj = None
self.img = None
# initialise texture
self.texture_background = None
self.K = None
self.mark_kp = None
self.mark_des = None
self.set_keypoint()
self.new_kp = None
self.mat_kp = None
self.mat_des = None
self.H = None
def real_time_lrp(conf):
"""Method to display feature relevance scores in real time.
Args:
conf: Dictionary consisting of configuration parameters.
"""
record_video = conf["playback"]["record_video"]
webcam = Webcam()
lrp = RelevancePropagation(conf)
if record_video:
recorder = VideoRecorder(conf)
while True:
t0 = time.time()
frame = webcam.get_frame()
heatmap = lrp.run(frame)
heatmap = post_processing(frame, heatmap, conf)
cv2.imshow("LRP", heatmap)
if record_video:
recorder.record(heatmap)
t1 = time.time()
fps = 1.0 / (t1 - t0)
print("{:.1f} FPS".format(fps))
if cv2.waitKey(1) % 256 == 27:
print("Escape pressed.")
break
if record_video:
recorder.release()
webcam.turn_off()
cv2.destroyAllWindows()
#2D image points. If you change the image, you need to change vector
image_points = np.array(
[
(359, 391), # Nose tip
(399, 561), # Chin
(337, 297), # Left eye left corner
(513, 301), # Right eye right corne
(345, 465), # Left Mouth corner
(453, 469) # Right mouth corner
],
dtype="double")
# 2d points in image plane.
webcam = Webcam()
#webcam.start()
def draw(img, corners, imgpts):
corner = tuple(corners[0].ravel())
img = cv2.line(img, corner, tuple(imgpts[0].ravel()), (255, 0, 0), 5)
img = cv2.line(img, corner, tuple(imgpts[1].ravel()), (0, 255, 0), 5)
img = cv2.line(img, corner, tuple(imgpts[2].ravel()), (0, 0, 255), 5)
return img
while True:
# get image from webcam
webcam.update_frame()
"%.0f" % frame_width_meters, "%.0f" % DISTANCE_METERS))
# -- other values used in program
base_image = None
abs_chg = 0
mph = 0
secs = 0.0
ix, iy = -1, -1
fx, fy = -1, -1
drawing = False
setup_complete = False
tracking = False
text_on_image = 'No cars'
prompt = ''
webcam = Webcam("calibrated.avi", FPS)
# create an image window and place it in the upper left corner of the screen
cv2.namedWindow("Speed Camera")
cv2.moveWindow("Speed Camera", 10, 40)
# call the draw_rectangle routines when the mouse is used
cv2.setMouseCallback('Speed Camera', draw_rectangle)
# grab a reference image to use for drawing the monitored area's boundry
image = webcam.get_image()
org_image = image.copy()
if SAVE_CSV:
csvfileout = "carspeed_{}.cvs".format(
datetime.datetime.now().strftime("%Y%m%d_%H%M"))
from webcam import Webcam
import cv2
from datetime import datetime
# termination criteria
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.001)
webcam = Webcam(1)
webcam.start()
def main():
while True:
#get the image
image = webcam.get_current_frame()
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow('grid', image)
ret, corners = cv2.findChessboardCorners(
image_gray, (9, 6), flags=cv2.cv.CV_CALIB_CB_ADAPTIVE_THRESH)
if ret == True:
print "found a chessboard"
cv2.drawChessboardCorners(image, (9, 6), corners, ret)
cv2.imshow('grid', image)
corners2 = cv2.cornerSubPix(image_gray, corners, (11, 11),
(-1, -1), criteria)
def main():
try:
camera_type = sys.argv[1]
recording = False
if len(sys.argv) == 3:
if sys.argv[2] == "record":
recording = True
else:
recording = False
if camera_type == "webcam":
collector = Webcam(video_width=640, video_height=480)
collector.start()
else:
print("No such camera {camera_type}")
collector = None
exit(-1)
if not os.path.isfile(MODEL_PATH):
print("Downloading model, please wait...")
download_file_from_google_drive(SOURCE, MODEL_PATH)
print("Done downloading the model.")
# get device
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
# initialise model
model = get_model_instance_segmentation(NUMBER_OF_CLASSES)
model.load_state_dict(
torch.load('./models/frcnn_hands.pth', map_location=device))
model.to(device)
model.eval()
if recording:
movie = cv2.VideoWriter(
f'./recordings/hand_frcnn_{camera_type}.avi',
cv2.VideoWriter_fourcc(*'DIVX'), 8, (640, 480))
with torch.no_grad():
while collector.started:
image, _ = collector.read()
if image is not None:
orig = image.copy()
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image = transforms.ToTensor()(image).to(device)
out = model([image])
boxes = get_prediction(pred=out, threshold=.7)
try:
for box in boxes:
cv2.rectangle(img=orig,
pt1=(box[0], box[1]),
pt2=(box[2], box[3]),
color=(0, 255, 255),
thickness=2)
if recording:
movie.write(orig)
cv2.imshow("mask", orig)
k = cv2.waitKey(1)
if k == ord('q'):
collector.stop()
except Exception as e:
print(e)
finally:
print("Stopping stream.")
collector.stop()
if recording:
movie.release()
cv2.destroyAllWindows()
