Eu fui capaz de detectar pupilas e os cantos dos olhos com precisão até agora. Você pode ver alguns snaps que eu enviei na minha resposta à minha própria pergunta aqui:

Realizando detecção estável de canto ocular

Aqui está o que eu fiz até agora. Calibrei o olhar do usuário olhando para TLCP, TRCP e BLCP onde

<code>CP = calibration point; a screen point used for calibration
B = bottom
T = top
L= left
R = right
gaze_width = TRCP.x - TLCP.x

gaze_height = BLCP.y- TLCP.y
</code>

E os pontos de vista correspondentes eu fico olhando para os CPs são chamados de GPs

cálculo de um ponto de vista GP:

Eu subtraio os valores das ordenanças do TLGP da localização atual do centro do aluno, porque o ponto do olhar tem que cair no retângulo hipotético, cujo eu espero que você entenda, é realmente muito simples.

Eu mapeei linearmente os pontos de olhar calculados da localização do centro da pupila para os pontos da tela usando um sistema básico de escala, onde as escalas são calculadas da seguinte forma:

<code>scaleX = screen_width/gaze_width
scaleY = screen_height/gaze_height
</code>

E para qualquer ponto de olhar P (x, y) eu calculo o ponto de tela correspondente Q (m, n) como:

<code>m = scaleX*x
n = scaleY*y
</code>

Mas o problema é que, mesmo após a detecção da pupila quase perfeita (quase porque, na iluminação fraca, isso dá falsos positivos. Mas eu pretendo colocar isso sob limitações porque não posso trabalhar nele, não tenho tempo suficiente), eu Eu ainda tenho uma largura de olhar pobre e altura do olhar.

Aqui está um log de teste:

<code>DO_CAL= True

Gaze Parameters:

TLGP = (38, 26) | TRGP = (20, 22) | BLGP = (39, 33)
screen height = 768 screen width = 1366

gaze height = 7 gaze width = 18

scales: X = 75.8888888889 | Y = 109.714285714
Thing on = True

Gaze point = (5, 3)
Screen point: (987, 329)

Gaze point = (5, 3)
Screen point: (987, 329)

Gaze point = (7, 5)
Screen point: (835, 549)

Thing on = False

TLGP = (37, 24) | TRGP = (22, 22) | BLGP = (35, 29)
screen height = 768 screen width = 1366

gaze height = 5 gaze width = 15
scales: X = 91.0666666667 | Y = 153.6
Thing on = True

Gaze point = (12, 3)
Screen point: (1093, 461)

Gaze point = (12, 3)
Screen point: (1093, 461)

ESC pressed
</code>

Basta olhar para os pontos do olhar e seus correspondentes pontos de tela detectados pelo olhar (abaixo deles). As grandes diferenças nos valores de x, y ordena estão me incomodando. Segunda é a apresentação final.

Depois dessa abordagem, eu teorizei outro em que:

A calibração é feita como no primeiro método. Eu detectaria o movimento do olhar e sua direção. Digamos, dados quaisquer dois pontos da localização do centro da pupila, P e Q, onde P é o primeiro ponto de vista, Q é o segundo, então calculamos a direção e o comprimento da linha PQ.

Vamos supor que o comprimento desse segmento de linha seja L. Então escalamos L para proporções de tela, digamos L é D na escala de tela, e dada a direção do movimento do olhar, movemos o cursor na tela a partir do seu último ponto de descanso, digamos R, D distance, para um novo ponto S que será calculado como o ponto final do segmento de linha cujo comprimento é D e ponto de partida S. A representação figurativa é dada na figura. Assim, basicamente, eu não mapeio nenhum dado do olhar para o ponto de tela, eu basicamente rastreio o olhar, e o converto em um "push" para ser aplicado ao cursor na tela. Mas ainda não implementei isso. Porque na verdade não mapeia o olhar para as coordenadas de tela e, portanto, pode estar errado. Motivações para essa teoria foram derivadas do projeto eViacam no sourceforge - elas basicamente rastreiam seu rosto e movem o mouse de acordo. Na calibração, eles calculam quanto seu rosto se move ao longo dos eixos.

Linha de fundo: Então, se algum de vocês tem alguma idéia de como detectar o olhar de um usuário a partir de uma imagem do olho perfeitamente processada -um com um centro de pupila detectado e cantos de olhopor favor diga! Eu tenho apenas um dia, e sei que está atrasado, mas eu só preciso de uma idéia mágica que possa me ajudar.