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 ... ```