Update eye_processor.py

This commit is contained in:
Prohurtz 2024-07-10 14:45:39 -07:00 committed by GitHub
parent 1d69fc110f
commit f8961d8616
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194

View File

@ -18,37 +18,28 @@
@@@ @ @@@@@@@@# @@@ @ @@@@@@@@#
@@@@@@@@@@@@@@@@@ @@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@( @@@@@@@@@@@@@(
HSR By: PallasNeko (Optimization Wizard, Contributor), Summer#2406 (Main Algorithm Engineer) Algorithm App Implementations By: Prohurtz, qdot (GUI, Initial Implementations), PallasNeko (Optimizations), Summer (Algorithim Engineer)
RANSAC 3D By: Summer#2406 (Main Algorithm Engineer), Pupil Labs (pye3d), PallasNeko (Optimization)
BLOB By: Prohurtz (Main App Developer)
Algorithm App Implementations By: Prohurtz, qdot (Initial App Creator), PallasNeko
Additional Contributors: [Assassin], Summer404NotFound, lorow, ZanzyTHEbar Additional Contributors: [Assassin], Summer404NotFound, lorow, ZanzyTHEbar
Copyright (c) 2023 EyeTrackVR <3 Copyright (c) 2023 EyeTrackVR <3
LICENSE: GNU GPLv3
------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------
""" """
from operator import truth
from dataclasses import dataclass
import sys import sys
import asyncio import asyncio
import os
os.environ["OMP_NUM_THREADS"] = "1"
sys.path.append(".") sys.path.append(".")
from config import EyeTrackCameraConfig from config import EyeTrackCameraConfig
from config import EyeTrackSettingsConfig from config import EyeTrackSettingsConfig
from pye3d.camera import CameraModel from pye3d.camera import CameraModel
from pye3d.detector_3d import Detector3D, DetectorMode from pye3d.detector_3d import Detector3D, DetectorMode
import queue import queue
import threading from eye import EyeId
import numpy as np
import cv2
from enum import Enum
from one_euro_filter import OneEuroFilter
from utils.misc_utils import PlaySound, SND_FILENAME, SND_ASYNC, resource_path
import importlib
from osc import EyeId
from osc_calibrate_filter import * from osc_calibrate_filter import *
from daddy import External_Run_DADDY from daddy import External_Run_DADDY
from leap import External_Run_LEAP from leap import External_Run_LEAP
@ -60,6 +51,7 @@ from utils.img_utils import circle_crop
from eye import EyeInfo, EyeInfoOrigin from eye import EyeInfo, EyeInfoOrigin
from intensity_based_openness import * from intensity_based_openness import *
from ellipse_based_pupil_dilation import * from ellipse_based_pupil_dilation import *
from AHSF import *
def run_once(f): def run_once(f):
@ -86,8 +78,8 @@ class EyeProcessor:
baseconfig: "EyetrackConfig", baseconfig: "EyetrackConfig",
cancellation_event: "threading.Event", cancellation_event: "threading.Event",
capture_event: "threading.Event", capture_event: "threading.Event",
capture_queue_incoming: "queue.Queue", capture_queue_incoming: "queue.Queue(maxsize=2)",
image_queue_outgoing: "queue.Queue", image_queue_outgoing: "queue.Queue(maxsize=2)",
eye_id, eye_id,
): ):
self.main_config = EyeTrackSettingsConfig self.main_config = EyeTrackSettingsConfig
@ -102,6 +94,8 @@ class EyeProcessor:
self.eye_id = eye_id self.eye_id = eye_id
self.baseconfig = baseconfig self.baseconfig = baseconfig
self.filterlist = [] self.filterlist = []
self.left_eye_data = [(0.351, 0.399, 1), (0.352, 0.400, 1)] # Example data
self.right_eye_data = [(0.351, 0.399, 1), (0.352, 0.400, 1)] # Example data
# Cross algo state # Cross algo state
self.lkg_projected_sphere = None self.lkg_projected_sphere = None
@ -122,9 +116,10 @@ class EyeProcessor:
self.yoff = 1 self.yoff = 1
# Keep large in order to recenter correctly # Keep large in order to recenter correctly
self.calibration_frame_counter = None self.calibration_frame_counter = None
self.calibration_3d_frame_counter = None
self.eyeoffx = 1 self.eyeoffx = 1
self.printcal = True self.printcal = True
self.grab_3d_point = False
self.xmax = -69420 self.xmax = -69420
self.xmin = 69420 self.xmin = 69420
self.ymax = -69420 self.ymax = -69420
@ -166,9 +161,10 @@ class EyeProcessor:
self.ran_blink_check_for_file = True self.ran_blink_check_for_file = True
self.bd_blink = False self.bd_blink = False
self.current_algo = EyeInfoOrigin.HSRAC self.current_algo = EyeInfoOrigin.HSRAC
self.puipil_width = 0.0 self.pupil_width = 0.0
self.pupil_height = 0.0 self.pupil_height = 0.0
self.avg_velocity = 0.0 self.avg_velocity = 0.0
self.angle = 621
try: try:
min_cutoff = float(self.settings.gui_min_cutoff) # 0.0004 min_cutoff = float(self.settings.gui_min_cutoff) # 0.0004
@ -178,9 +174,7 @@ class EyeProcessor:
min_cutoff = 0.0004 min_cutoff = 0.0004
beta = 0.9 beta = 0.9
noisy_point = np.array([1, 1]) noisy_point = np.array([1, 1])
self.one_euro_filter = OneEuroFilter( self.one_euro_filter = OneEuroFilter(noisy_point, min_cutoff=min_cutoff, beta=beta)
noisy_point, min_cutoff=min_cutoff, beta=beta
)
def output_images_and_update(self, threshold_image, output_information: EyeInfo): def output_images_and_update(self, threshold_image, output_information: EyeInfo):
try: try:
@ -195,17 +189,12 @@ class EyeProcessor:
self.previous_image = self.current_image self.previous_image = self.current_image
self.previous_rotation = self.config.rotation_angle self.previous_rotation = self.config.rotation_angle
except: # If this fails it likely means that the images are not the same size for some reason. except: # If this fails it likely means that the images are not the same size for some reason.
print( print("\033[91m[ERROR] Size of frames to display are of unequal sizes.\033[0m")
"\033[91m[ERROR] Size of frames to display are of unequal sizes.\033[0m"
)
pass
def capture_crop_rotate_image(self): def capture_crop_rotate_image(self):
# Get our current frame # Get our current frame
self.ibo.change_roi(self.config.dict(include=self.roi_include_set)) self.ibo.change_roi(self.config.dict(include=self.roi_include_set))
roi_x = self.config.roi_window_x roi_x = self.config.roi_window_x
roi_y = self.config.roi_window_y roi_y = self.config.roi_window_y
roi_w = self.config.roi_window_w roi_w = self.config.roi_window_w
@ -215,16 +204,38 @@ class EyeProcessor:
try: try:
# Apply rotation to cropped area. For any rotation area outside of the bounds of the image, # Apply rotation to cropped area. For any rotation area outside of the bounds of the image,
# fill with avg color + 10.
# fill with white (self.current_image_white) and average in-bounds color (self.current_image). # fill with white (self.current_image_white) and average in-bounds color (self.current_image).
crop_matrix = np.float32([[1, 0, -roi_x], crop_matrix = np.float32([[1, 0, -roi_x],
[0, 1, -roi_y], [0, 1, -roi_y],
[0, 0, 1]]) [0, 0, 1]])
img_center = (roi_w / 2, roi_h / 2) img_center = (roi_w / 2, roi_h / 2)
rotation_matrix = cv2.getRotationMatrix2D( rotation_matrix = cv2.getRotationMatrix2D(
img_center, self.config.rotation_angle, 1 img_center, self.config.rotation_angle, 1
) )
# rows, cols = self.current_image.shape[:2]
# rotation_matrix = cv2.getRotationMatrix2D((cols / 2, rows / 2), self.config.rotation_angle, 1)
#cos_theta = np.abs(rotation_matrix[0, 0])
# sin_theta = np.abs(rotation_matrix[0, 1])
# new_cols = int((cols * cos_theta) + (rows * sin_theta))
# new_rows = int((cols * sin_theta) + (rows * cos_theta))
# rotation_matrix[0, 2] += (new_cols - cols) / 2
# rotation_matrix[1, 2] += (new_rows - rows) / 2
matrix = np.matmul(rotation_matrix, crop_matrix) matrix = np.matmul(rotation_matrix, crop_matrix)
self.current_image_white = cv2.warpAffine(
self.current_image,
matrix,
(roi_w, roi_h),
borderMode=cv2.BORDER_CONSTANT,
borderValue=(255, 255, 255),
)
self.current_image_white = cv2.warpAffine( self.current_image_white = cv2.warpAffine(
self.current_image, self.current_image,
@ -234,14 +245,11 @@ class EyeProcessor:
borderValue=(255, 255, 255), borderValue=(255, 255, 255),
) )
# calculate position of all four corners of crop, and check if any are out of bounds
# add w-preserve row to make matrix square, invert, and remove again
inv_matrix = np.linalg.inv(np.vstack((matrix, [0, 0, 1])))[:-1] inv_matrix = np.linalg.inv(np.vstack((matrix, [0, 0, 1])))[:-1]
# calculate crop corner locations in original image space # calculate crop corner locations in original image space
corners = np.matmul([[0, 0, 1], corners = np.matmul([[0, 0, 1],
[roi_w, 0, 1], [roi_w, 0, 1],
[0, roi_h, 1], [0, roi_h, 1],
[roi_w, roi_h, 1]], [roi_w, roi_h, 1]],
np.transpose(inv_matrix)) np.transpose(inv_matrix))
fits_in_bounds = all(0 <= x <= img_w and 0 <= y <= img_h fits_in_bounds = all(0 <= x <= img_w and 0 <= y <= img_h
@ -266,7 +274,6 @@ class EyeProcessor:
borderValue=(0, 0, 0, 0), borderValue=(0, 0, 0, 0),
) )
# calculate average color of crop, excluding alpha
avg_color_per_row = np.average(self.current_image, axis=0) avg_color_per_row = np.average(self.current_image, axis=0)
avg_color = np.average(avg_color_per_row, axis=0) avg_color = np.average(avg_color_per_row, axis=0)
avg_color_norm = avg_color[0:3] / avg_color[3] avg_color_norm = avg_color[0:3] / avg_color[3]
@ -281,6 +288,7 @@ class EyeProcessor:
inv_alpha_ch * ab]), inv_alpha_ch * ab]),
axis=-1) axis=-1)
return True return True
except: except:
pass pass
@ -301,9 +309,8 @@ class EyeProcessor:
self.settings.ibo_filter_samples, self.settings.ibo_filter_samples,
self.settings.ibo_average_output_samples, self.settings.ibo_average_output_samples,
) )
if self.eyeopen < float( # threshold so the eye fully closes
self.settings.ibo_fully_close_eye_threshold if self.eyeopen < float(self.settings.ibo_fully_close_eye_threshold):
): # threshold so the eye fully closes
self.eyeopen = 0.0 self.eyeopen = 0.0
if self.bd_blink == True: if self.bd_blink == True:
@ -325,12 +332,10 @@ class EyeProcessor:
self.rawx, self.rawx,
self.rawy, self.rawy,
self.eyeopen, self.eyeopen,
) = self.er_leap.run(self.current_image_gray) ) = self.er_leap.run(self.current_image_gray, self.current_image_gray_clean)
# print(self.eyeopen) # print(self.eyeopen)
if ( if len(self.prev_y_list) >= 100: # "lock" eye when close/blink IN TESTING, kinda broke
len(self.prev_y_list) >= 100
): # "lock" eye when close/blink IN TESTING, kinda broke
self.prev_y_list.pop(0) self.prev_y_list.pop(0)
self.prev_y_list.append(self.out_y) self.prev_y_list.append(self.out_y)
else: else:
@ -383,18 +388,12 @@ class EyeProcessor:
def LEAPM(self): def LEAPM(self):
self.thresh = self.current_image_gray.copy() self.thresh = self.current_image_gray.copy()
( (self.current_image_gray, self.rawx, self.rawy, self.eyeopen,) = self.er_leap.run(
self.current_image_gray, self.current_image_gray, self.current_image_gray_clean
self.rawx,
self.rawy,
self.eyeopen,
) = self.er_leap.run(
self.current_image_gray
) # TODO: make own self var and LEAP toggle ) # TODO: make own self var and LEAP toggle
self.thresh = self.current_image_gray.copy() self.thresh = self.current_image_gray.copy()
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc( # todo: lorow, fix this as well
self, self.rawx, self.rawy self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
)
self.current_algorithm = EyeInfoOrigin.LEAP self.current_algorithm = EyeInfoOrigin.LEAP
# print(self.eyeopen) # print(self.eyeopen)
@ -405,11 +404,54 @@ class EyeProcessor:
self.thresh = self.current_image_gray.copy() self.thresh = self.current_image_gray.copy()
self.rawx, self.rawy, self.radius = self.er_daddy.run(self.current_image_gray) self.rawx, self.rawy, self.radius = self.er_daddy.run(self.current_image_gray)
# Daddy also uses a one euro filter, so I'll have to use it twice, but I'm not going to think too much about it. # Daddy also uses a one euro filter, so I'll have to use it twice, but I'm not going to think too much about it.
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc( self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
self, self.rawx, self.rawy
)
self.current_algorithm = EyeInfoOrigin.DADDY self.current_algorithm = EyeInfoOrigin.DADDY
def AHSFRACM(self):
if self.eye_id in [EyeId.LEFT] and self.settings.gui_circular_crop_left:
self.current_image_gray, self.cct = circle_crop(
self.current_image_gray, self.xc, self.yc, self.cc_radius, self.cct
)
else:
pass
if self.eye_id in [EyeId.RIGHT] and self.settings.gui_circular_crop_right:
self.current_image_gray, self.cct = circle_crop(
self.current_image_gray, self.xc, self.yc, self.cc_radius, self.cct
)
else:
pass
self.hasrac_en = True
(
self.current_image_gray,
resize_img,
self.rawx,
self.rawy,
self.radius,
) = External_Run_AHSF(self.current_image_gray)
self.current_image_gray_clean = resize_img.copy()
self.thresh = resize_img
(
self.rawx,
self.rawy,
self.angle,
self.thresh,
ranblink,
self.pupil_width,
self.pupil_height,
) = RANSAC3D(self, True)
if self.settings.gui_RANSACBLINK: # might be redundant
self.eyeopen = ranblink
# print("RANBLINK", ranblink)
# print(self.radius)
# if self.prev_x is None:
# self.prev_x = self.rawx
# self.prev_y = self.rawy
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
self.current_algorithm = EyeInfoOrigin.HSRAC
def HSRACM(self): def HSRACM(self):
if self.eye_id in [EyeId.LEFT] and self.settings.gui_circular_crop_left: if self.eye_id in [EyeId.LEFT] and self.settings.gui_circular_crop_left:
self.current_image_gray, self.cct = circle_crop( self.current_image_gray, self.cct = circle_crop(
@ -425,13 +467,11 @@ class EyeProcessor:
pass pass
self.hasrac_en = True self.hasrac_en = True
# todo: add process to initialise er_hsrac when resolution changes self.rawx, self.rawy, self.thresh, self.radius = self.er_hsf.run(self.current_image_gray)
self.rawx, self.rawy, self.thresh, self.radius = self.er_hsf.run(
self.current_image_gray
)
( (
self.rawx, self.rawx,
self.rawy, self.rawy,
self.angle,
self.thresh, self.thresh,
ranblink, ranblink,
self.pupil_width, self.pupil_width,
@ -445,9 +485,7 @@ class EyeProcessor:
# if self.prev_x is None: # if self.prev_x is None:
# self.prev_x = self.rawx # self.prev_x = self.rawx
# self.prev_y = self.rawy # self.prev_y = self.rawy
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc( self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
self, self.rawx, self.rawy
)
self.current_algorithm = EyeInfoOrigin.HSRAC self.current_algorithm = EyeInfoOrigin.HSRAC
def HSFM(self): def HSFM(self):
@ -464,12 +502,8 @@ class EyeProcessor:
else: else:
pass pass
# todo: add process to initialise er_hsf when resolution changes # todo: add process to initialise er_hsf when resolution changes
self.rawx, self.rawy, self.thresh, self.radius = self.er_hsf.run( self.rawx, self.rawy, self.thresh, self.radius = self.er_hsf.run(self.current_image_gray)
self.current_image_gray self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
)
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(
self, self.rawx, self.rawy
)
self.current_algorithm = EyeInfoOrigin.HSF self.current_algorithm = EyeInfoOrigin.HSF
def RANSAC3DM(self): def RANSAC3DM(self):
@ -486,12 +520,11 @@ class EyeProcessor:
else: else:
pass pass
self.hasrac_en = False self.hasrac_en = False
current_image_gray_copy = ( current_image_gray_copy = self.current_image_gray.copy() # Duplicate before overwriting in RANSAC3D.
self.current_image_gray.copy()
) # Duplicate before overwriting in RANSAC3D.
( (
self.rawx, self.rawx,
self.rawy, self.rawy,
self.angle,
self.thresh, self.thresh,
ranblink, ranblink,
self.pupil_width, self.pupil_width,
@ -499,11 +532,33 @@ class EyeProcessor:
) = RANSAC3D(self, True) ) = RANSAC3D(self, True)
if self.settings.gui_RANSACBLINK: if self.settings.gui_RANSACBLINK:
self.eyeopen = ranblink self.eyeopen = ranblink
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc( self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
self, self.rawx, self.rawy
)
self.current_algorithm = EyeInfoOrigin.RANSAC self.current_algorithm = EyeInfoOrigin.RANSAC
def AHSFM(self):
if self.eye_id in [EyeId.LEFT] and self.settings.gui_circular_crop_left:
self.current_image_gray, self.cct = circle_crop(
self.current_image_gray, self.xc, self.yc, self.cc_radius, self.cct
)
else:
pass
if self.eye_id in [EyeId.RIGHT] and self.settings.gui_circular_crop_right:
self.current_image_gray, self.cct = circle_crop(
self.current_image_gray, self.xc, self.yc, self.cc_radius, self.cct
)
else:
pass
(
self.current_image_gray,
resize_img,
self.rawx,
self.rawy,
self.radius,
) = External_Run_AHSF(self.current_image_gray)
self.thresh = self.current_image_gray
self.out_x, self.out_y, self.avg_velocity = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
self.current_algorithm = EyeInfoOrigin.HSF
def BLOBM(self): def BLOBM(self):
if self.eye_id in [EyeId.LEFT] and self.settings.gui_circular_crop_left: if self.eye_id in [EyeId.LEFT] and self.settings.gui_circular_crop_left:
self.current_image_gray, self.cct = circle_crop( self.current_image_gray, self.cct = circle_crop(
@ -519,41 +574,41 @@ class EyeProcessor:
pass pass
self.rawx, self.rawy, self.thresh = BLOB(self) self.rawx, self.rawy, self.thresh = BLOB(self)
self.out_x, self.out_y = cal.cal_osc(self, self.rawx, self.rawy) self.out_x, self.out_y = cal.cal_osc(self, self.rawx, self.rawy, self.angle)
self.current_algorithm = EyeInfoOrigin.BLOB self.current_algorithm = EyeInfoOrigin.BLOB
def ALGOSELECT(self): def ALGOSELECT(self):
# self.DADDYM() # send the tracking algos previous fail number, in algo if we pass set to 0, if fail, + 1
if self.failed == 0 and self.firstalgo != None: if self.failed == 0 and self.firstalgo != None:
self.firstalgo() self.firstalgo()
else: else:
self.failed = self.failed + 1 self.failed = self.failed + 1
if self.failed == 1 and self.secondalgo != None:
if (
self.failed == 1 and self.secondalgo != None
): # send the tracking algos previous fail number, in algo if we pass set to 0, if fail, + 1
self.secondalgo() self.secondalgo()
else: else:
self.failed = self.failed + 1 self.failed = self.failed + 1
if self.failed == 2 and self.thirdalgo != None: if self.failed == 2 and self.thirdalgo != None:
self.thirdalgo() self.thirdalgo()
else: else:
self.failed = self.failed + 1 self.failed = self.failed + 1
if self.failed == 3 and self.fourthalgo != None: if self.failed == 3 and self.fourthalgo != None:
self.fourthalgo() self.fourthalgo()
else: else:
self.failed = self.failed + 1 self.failed = self.failed + 1
if self.failed == 4 and self.fithalgo != None: if self.failed == 4 and self.fithalgo != None:
self.fithalgo() self.fithalgo()
else: else:
self.failed = self.failed + 1 self.failed = self.failed + 1
if self.failed == 5 and self.sixthalgo != None: if self.failed == 5 and self.sixthalgo != None:
self.sixthalgo() self.sixthalgo()
else:
self.failed = self.failed + 1
if self.failed == 6 and self.seventhalgo != None:
self.seventhalgo()
else:
self.failed = self.failed + 1
if self.failed == 7 and self.eigthalgo != None:
self.eigthalgo()
else: else:
self.failed = 0 # we have reached last possible algo and it is disabled, move to first algo self.failed = 0 # we have reached last possible algo and it is disabled, move to first algo
@ -567,11 +622,22 @@ class EyeProcessor:
self.fourthalgo = None self.fourthalgo = None
self.fithalgo = None self.fithalgo = None
self.sixthalgo = None self.sixthalgo = None
algolist = [None, None, None, None, None, None, None] self.seventhalgo = None
self.eigthalgo = None
algolist = [None, None, None, None, None, None, None, None, None]
# clear HSF values when page is opened to correctly reflect setting changes # clear HSF values when page is opened to correctly reflect setting changes
self.er_hsf = None self.er_hsf = None
# algolist[self.settings.gui_HSFP] = self.HSFM
# set algo priorities # set algo priorities
if self.settings.gui_AHSFRAC:
algolist[self.settings.gui_AHSFRACP] = self.AHSFRACM
if self.settings.gui_AHSF:
algolist[self.settings.gui_AHSFP] = self.AHSFM
if self.settings.gui_HSF: if self.settings.gui_HSF:
if self.er_hsf is None: if self.er_hsf is None:
if self.eye_id in [EyeId.LEFT]: if self.eye_id in [EyeId.LEFT]:
@ -588,16 +654,16 @@ class EyeProcessor:
) )
else: else:
pass pass
algolist[self.settings.gui_HSFP] = self.HSFM algolist[self.settings.gui_HSFP] = self.HSFM
else: else:
if self.er_hsf is not None: if self.er_hsf is not None:
self.er_hsf = None self.er_hsf = None
if self.settings.gui_HSRAC: if self.settings.gui_HSRAC:
if self.er_hsf is None: if self.er_hsf is None:
if self.eye_id in [EyeId.LEFT]: if self.eye_id in [EyeId.LEFT]:
self.er_hsf = External_Run_HSF( self.er_hsf = External_Run_HSF(
self.settings.gui_skip_autoradius, self.settings.gui_skip_autoradius,
self.settings.gui_HSF_radius_left, self.settings.gui_HSF_radius_left,
@ -611,6 +677,7 @@ class EyeProcessor:
) )
else: else:
pass pass
algolist[self.settings.gui_HSRACP] = self.HSRACM algolist[self.settings.gui_HSRACP] = self.HSRACM
else: else:
if not self.settings.gui_HSF and self.er_hsf is not None: if not self.settings.gui_HSF and self.er_hsf is not None:
@ -646,11 +713,14 @@ class EyeProcessor:
self.fourthalgo, self.fourthalgo,
self.fithalgo, self.fithalgo,
self.sixthalgo, self.sixthalgo,
self.seventhalgo,
self.eigthalgo,
) = algolist ) = algolist
f = True f = True
while True: while True:
# f = True # f = True
# print(self.capture_queue_incoming.qsize())
# Check to make sure we haven't been requested to close # Check to make sure we haven't been requested to close
if self.cancellation_event.is_set(): if self.cancellation_event.is_set():
print("\033[94m[INFO] Exiting Tracking thread\033[0m") print("\033[94m[INFO] Exiting Tracking thread\033[0m")
@ -676,9 +746,7 @@ class EyeProcessor:
focal_length=self.config.focal_length, focal_length=self.config.focal_length,
resolution=(self.config.roi_window_w, self.config.roi_window_h), resolution=(self.config.roi_window_w, self.config.roi_window_h),
) )
self.detector_3d = Detector3D( self.detector_3d = Detector3D(camera=self.camera_model, long_term_mode=DetectorMode.blocking)
camera=self.camera_model, long_term_mode=DetectorMode.blocking
)
try: try:
if self.capture_queue_incoming.empty(): if self.capture_queue_incoming.empty():
@ -688,7 +756,7 @@ class EyeProcessor:
self.current_image, self.current_image,
self.current_frame_number, self.current_frame_number,
self.current_fps, self.current_fps,
) = self.capture_queue_incoming.get(block=True, timeout=0.2) ) = self.capture_queue_incoming.get(block=True, timeout=0.1)
except queue.Empty: except queue.Empty:
# print("No image available") # print("No image available")
continue continue
@ -696,12 +764,14 @@ class EyeProcessor:
if not self.capture_crop_rotate_image(): if not self.capture_crop_rotate_image():
continue continue
self.current_image_gray = cv2.cvtColor( self.current_image_gray = cv2.cvtColor(self.current_image, cv2.COLOR_BGR2GRAY)
self.current_image, cv2.COLOR_BGR2GRAY
)
self.current_image_gray_clean = ( self.current_image_gray_clean = (
self.current_image_gray.copy() self.current_image_gray.copy()
) # copy this frame to have a clean image for blink algo ) # copy this frame to have a clean image for blink algo
self.ALGOSELECT() # run our algos in priority order set in settings if self.cancellation_event.is_set():
self.UPDATE() print("\033[94m[INFO] Exiting Tracking thread\033[0m")
return
else:
self.ALGOSELECT() # run our algos in priority order set in settings
self.UPDATE()