1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
Script the pipeline
===================
All gaze analysis pipeline objects are accessible from Python script.
This could be particularly useful for realtime gaze interaction applications.
## Load ArFrame configuration from dictionary
First of all, [ArFrame](../../../argaze.md/#argaze.ArFeatures.ArFrame) configuration can be loaded from a python dictionary.
```python
from argaze import ArFeatures
# Edit a dict with ArFrame configuration
configuration = {
"name": "My FullHD screen",
"size": (1920, 1080),
...
"gaze_movement_identifier": {
...
},
"scan_path": {
...
},
"scan_path_analyzers": {
...
},
"heatmap": {
...
},
"layers": {
"MyLayer": {
...
},
...
},
"image_parameters": {
...
}
}
# Load ArFrame
ar_frame = ArFeatures.ArFrame.from_dict(configuration)
# Do something with ArFrame
...
```
## Access to ArFrame and ArLayers attributes
Then, once the configuration is loaded, it is possible to access to its attributes: [read ArFrame code reference](../../../argaze.md/#argaze.ArFeatures.ArFrame) to get a complete list of what is available.
Thus, the [ArFrame.layers](../../../argaze.md/#argaze.ArFeatures.ArFrame) attribute allows to access each loaded layer and so, access to their attributes: [read ArLayer code reference](../../../argaze.md/#argaze.ArFeatures.ArLayer) to get a complete list of what is available.
```python
from argaze import ArFeatures
# Assuming the ArFrame is loaded
...
# Iterate over each ArFrame layers
for name, ar_layer in ar_frame.layers.items():
...
```
## Pipeline execution updates
Calling [ArFrame.look](../../../argaze.md/#argaze.ArFeatures.ArFrame.look) method leads to update many data into the pipeline.
```python
# Assuming that timestamped gaze positions are available
...
try:
# Look ArFrame at a timestamped gaze position and iterate over analysis
for element, module, analysis in ar_frame.look(timestamp, gaze_position):
# Ckeck if analysis comes from frame
if ArFeatures.is_frame(element):
# Do something with scan path module analysis
...
# Ckeck if analysis comes from frame
elif ArFeatures.is_layer(element):
# Do something with aoi scan path module analysis
...
# Do something with calibrated gaze position
... ar_frame.gaze_position
# Check if a gaze movement has been identified
if ar_frame.gaze_movement.valid and ar_frame.gaze_movement.finished:
# Do something with identified fixation
if GazeFeatures.is_fixation(ar_frame.gaze_movement):
...
# Do something with identified saccade
elif GazeFeatures.is_saccade(ar_frame.gaze_movement):
...
# Do something with pipeline exception
except Exception as e:
...
```
Let's understand the meaning of each data.
### *element, module, analysis*
Looking at [ArFrame](../../../argaze.md/#argaze.ArFeatures.ArFrame) leads inner [ArFrame](../../../argaze.md/#argaze.ArFeatures.ArFrame) scan path analyzers and inner [Arlayers](../../../argaze.md/#argaze.ArFeatures.ArLayer) aoi scan path analysis to produce analysis.
The *element* returning analysis can be tested thanks to [ArFeatures.is_frame](../../../argaze.md/#argaze.ArFeatures.is_frame) and [ArFeatures.is_layer](../../../argaze.md/#argaze.ArFeatures.is_layer) functions.
The *module* is the type of scan path or aoi scan path analyzer.
The *analysis* is a dictionnary containing all analysis produced by the module.
### *ar_frame.gaze_position*
This is the calibrated [GazePosition](../../../argaze.md/#argaze.GazeFeatures.GazePosition) returned by [GazePositionCalibrator](../../../argaze.md/#argaze.GazeFeatures.GazePositionCalibrator) if one is instanciated else, it is the given [GazePosition](../../../argaze.md/#argaze.GazeFeatures.GazePosition).
### *ar_frame.gaze_movement*
A [GazeMovement](../../../argaze.md/#argaze.GazeFeatures.GazeMovement) once it have been identified by [ArFrame.gaze_movement_identifier](../../../argaze.md/#argaze.ArFeatures.ArFrame) object from incoming consecutive timestamped gaze positions. If no gaze movement have been identified, it returns an [UnvalidGazeMovement](../../../argaze.md/#argaze.GazeFeatures.UnvalidGazeMovement).
This could also be the current gaze movement if [ArFrame.filter_in_progress_identification](../../../argaze.md/#argaze.ArFeatures.ArFrame) attribute is false.
In that case, the returned gaze movement *finished* flag is false.
Then, the returned gaze movement type can be tested thanks to [GazeFeatures.is_fixation](../../../argaze.md/#argaze.GazeFeatures.is_fixation) and [GazeFeatures.is_saccade](../../../argaze.md/#argaze.GazeFeatures.is_saccade) functions.
### *ar_frame.new_analysis_available* and *ar_layer.new_analysis_available*
This flag allows to now when new scan path and aoi scan path analysis are available.
### *analyzer.analysis*
A dictionary containing all data produced by an analyzer.
## Setup ArFrame image parameters
[ArFrame.image](../../../argaze.md/#argaze.ArFeatures.ArFrame.image) method parameters can be configured thanks to a python dictionary.
```python
# Assuming ArFrame is loaded
...
# Edit a dict with ArFrame image parameters
image_parameters = {
"draw_scan_path": {
...
},
"draw_layers": {
"MyLayer": {
...
}
},
...
}
# Pass image parameters to ArFrame
ar_frame_image = ar_frame.image(**image_parameters)
# Do something with ArFrame image
...
```
|
