KIAPBCI/kiap_bci/paradigms/exploration.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 24 16:16:05 2018

@author: ale
"""
import os
import random

from aux import log
from paradigm import Paradigm


class Exploration(Paradigm):
    '''
    Paradigm to discriminate between several mental states. Different stimuli 
    are presented based on the configuration file.
    '''
    def __init__(self, **kwargs):
        '''
        Initilalize the paradigm
        
        Variables:
            states_idx: string (index of the selected states)
            states: string (name of the selected states and of the corresponding wav files)
            audio_path: string (path where the audio files are stored)
            num_stim: int (number of stimuli presented for each state)
            mode: string (mode of the paradigm)
            list_of_index: list[int] (indexes of stimuli that will be presented)
            list_of_stimuli: list[string] (stimuli that will be presented)
            current_stimulus: string (current stimulus)
            current_idx: int (index of current stimulus)
            history: list[(int,str)] (history of the stimulus presentation: index, stimulus)
        '''
        super().__init__(**kwargs)
        
        # read configuration file
        config = self.params.paradigms.exploration
        all_states = config.states
        self.states_idx = config.selected_states
        self.states = [all_states[idx] for idx in self.states_idx]
        self.audio_path = config.audio_path
        self.num_stim = config.number_of_stim
        
        self.mode = config.mode[config.selected_mode]
        self.list_of_index = self._create_list()
        self.list_of_stimuli = [all_states[idx] for idx in self.list_of_index]
        
        self.current_stimulus = self.list_of_stimuli.pop(0)
        self.current_idx = self.list_of_index.pop(0)
        self.start_triger = [110, 111]
        
        self.history = []
        
    def _create_list(self):
        '''
        Create the list of stimuli randomizing the states
        
        Return:
            all_idx: list (list of randomizing states)
        '''
        all_idx = self.states_idx * self.num_stim
        random.shuffle(all_idx)
        
        return all_idx
        
    def process_result(self, decision=None, audio=False):
        ''' 
        Append the last index and string stimulus to history.
        Update the current_idx and current_stimulus variables popping from corresponding lists
        
        Parameters:
            decision: boolean (value of the last decision)
            
        Return:
            finish: boolean (True if the paradigm is finished, False otherwise)            
        '''
        
        self.history.append([self.current_idx,self.current_stimulus])
        
        if self.list_of_stimuli:
            self.current_stimulus = self.list_of_stimuli.pop(0)
            self.current_idx = self.list_of_index.pop(0)
            finish = False
        else:
            finish = True
            self.current_stimulus = ''
            log.info('Stimulus list is empty.')
            
        return finish
            
    def present_stimulus(self, audio=True):
        ''' 
        Play auditorly the current stimulus using the play function defined in 
        the abstract class
        
        Return:
            current_stimulus: string (the stimulus that is presented)
        '''
        if audio:
            stim_path = self.audio_path+os.sep+self.current_stimulus+'.wav'
            try:
                self._play_sound(stim_path,self.current_idx,self.current_idx+100)
            except Exception as e:
                raise e
        return self.current_stimulus

    def present_start(self, audio=True):
        '''
        Play auditorly the start stimulus using the play function defined in
        the abstract class

        Return:
            None
        '''
        if audio:
            stim_path = self.audio_path.split('/exploration')[0] + os.sep + 'beginning.wav'
            try:
                self._play_sound(stim_path, self.start_triger, self.start_triger)
            except Exception as e:
                raise e
        return None
        
    def get_current_state(self):
        '''
        Return the current state
        
        Return:
            current_idx: str (index of the current state)
            current_stimulus str (current state)
        
        '''

        return str(self.current_idx), self.current_stimulus
    def get_mode(self):
        '''
        Return the mode of the used paradigm
        
        Return:
            mode: string (mode of the paradigm)
        
        '''
        return self.mode
    
    def save_log(self):
        '''
        Save the log
        
        '''
        pass