コード例 #1
0
ファイル: stereo.py プロジェクト: chrox/RealTimeElectrophy
    def __init__(self, subject, pre_fix):
        self.logger = Logger(subject, pre_fix)

        self.trialsDesired = 50
        startVal = 0.5
        nReversals = 10
        stepSizes = [0.03, 0.01, 0.01, 0.005, 0.005, 0.002, 0.001]
        nTrials = 50
        nUp = 1
        nDown = 3
        stepType = "lin"
        minVal = 0
        maxVal = 0.5

        self.staircase_obj = StaircaseObject(startVal, nReversals, stepSizes,
                                             nTrials, nUp, nDown, stepType,
                                             minVal, maxVal)

        self.logger.write("Staircase for Stereo Threshold measurement")
        self.logger.write("Staircase object is initiated with "
                          "startVal:%.2f "
                          "nReversals:%.2f "
                          "stepSizes:%s "
                          "nTrials:%.2f "
                          "nUp:%.2f "
                          "nDown:%.2f "
                          "minVal:%.2f "
                          "maxVal:%.2f " %
                          (startVal, nReversals, stepSizes, nTrials, nUp,
                           nDown, minVal, maxVal))
        self.logger.write("Staircase trials is set to %d" % nTrials)
コード例 #2
0
ファイル: sed.py プロジェクト: chrox/RealTimeElectrophy
 def __init__(self, subject, pre_fix, contrast):
     self.logger = Logger(subject, pre_fix)
     self.control_contrast = contrast
     
     tGuess = math.log10(self.control_contrast)
     tGuessSd = 2.0 # sd of Gaussian before clipping to specified range
     pThreshold = 0.82
     #beta = 3.5
     beta = 4.0
     delta = 0.01
     gamma = 0.5
     grain = 0.01
     scope = 3
     
     self.quest_obj = QuestObject(tGuess=tGuess,tGuessSd=tGuessSd,pThreshold=pThreshold,
                                  beta=beta,delta=delta,gamma=gamma,grain=grain,scope=scope)
     self.trialsDesired = 50
     
     self.logger.write("QUEST for Sensory Eye Dominance(SED) measurement")
     self.logger.write("Quest object is initiated with "
                       "tGuess:%.2f "
                       "tGuessSd:%.2f "
                       "pThreshold:%.2f "
                       "beta:%.2f "
                       "delta:%.2f "
                       "gamma:%.2f "
                       "grain:%.2f "
                       "scope:%.2f "
                       %(tGuess,tGuessSd,pThreshold,beta,delta,gamma,grain,scope))
     self.logger.write("Quest trials is set to %d" %self.trialsDesired)
コード例 #3
0
ファイル: stereo.py プロジェクト: chrox/RealTimeElectrophy
 def __init__(self, subject, pre_fix):
     self.logger = Logger(subject, pre_fix)
     
     self.trialsDesired = 50
     startVal = 0.5
     nReversals = 10
     stepSizes = [0.03, 0.01, 0.01, 0.005, 0.005, 0.002, 0.001]
     nTrials = 50
     nUp = 1
     nDown = 3
     stepType = "lin"
     minVal = 0
     maxVal = 0.5
     
     self.staircase_obj = StaircaseObject(
             startVal, nReversals, stepSizes,
             nTrials, nUp, nDown,
             stepType, minVal, maxVal)
     
     self.logger.write("Staircase for Stereo Threshold measurement")
     self.logger.write("Staircase object is initiated with "
                       "startVal:%.2f "
                       "nReversals:%.2f "
                       "stepSizes:%s "
                       "nTrials:%.2f "
                       "nUp:%.2f "
                       "nDown:%.2f "
                       "minVal:%.2f "
                       "maxVal:%.2f "
                       %(startVal,nReversals,stepSizes,nTrials,nUp,nDown,minVal,maxVal))
     self.logger.write("Staircase trials is set to %d" %nTrials)
コード例 #4
0
ファイル: sed.py プロジェクト: chrox/RealTimeElectrophy
    def __init__(self, subject, pre_fix, contrast):
        self.logger = Logger(subject, pre_fix)
        self.control_contrast = contrast

        tGuess = math.log10(self.control_contrast)
        tGuessSd = 2.0  # sd of Gaussian before clipping to specified range
        pThreshold = 0.82
        #beta = 3.5
        beta = 4.0
        delta = 0.01
        gamma = 0.5
        grain = 0.01
        scope = 3

        self.quest_obj = QuestObject(tGuess=tGuess,
                                     tGuessSd=tGuessSd,
                                     pThreshold=pThreshold,
                                     beta=beta,
                                     delta=delta,
                                     gamma=gamma,
                                     grain=grain,
                                     scope=scope)
        self.trialsDesired = 50

        self.logger.write("QUEST for Sensory Eye Dominance(SED) measurement")
        self.logger.write(
            "Quest object is initiated with "
            "tGuess:%.2f "
            "tGuessSd:%.2f "
            "pThreshold:%.2f "
            "beta:%.2f "
            "delta:%.2f "
            "gamma:%.2f "
            "grain:%.2f "
            "scope:%.2f " %
            (tGuess, tGuessSd, pThreshold, beta, delta, gamma, grain, scope))
        self.logger.write("Quest trials is set to %d" % self.trialsDesired)
コード例 #5
0
ファイル: sed.py プロジェクト: chrox/RealTimeElectrophy
class Quest(object):
    def __init__(self, subject, pre_fix, contrast):
        self.logger = Logger(subject, pre_fix)
        self.control_contrast = contrast
        
        tGuess = math.log10(self.control_contrast)
        tGuessSd = 2.0 # sd of Gaussian before clipping to specified range
        pThreshold = 0.82
        #beta = 3.5
        beta = 4.0
        delta = 0.01
        gamma = 0.5
        grain = 0.01
        scope = 3
        
        self.quest_obj = QuestObject(tGuess=tGuess,tGuessSd=tGuessSd,pThreshold=pThreshold,
                                     beta=beta,delta=delta,gamma=gamma,grain=grain,scope=scope)
        self.trialsDesired = 50
        
        self.logger.write("QUEST for Sensory Eye Dominance(SED) measurement")
        self.logger.write("Quest object is initiated with "
                          "tGuess:%.2f "
                          "tGuessSd:%.2f "
                          "pThreshold:%.2f "
                          "beta:%.2f "
                          "delta:%.2f "
                          "gamma:%.2f "
                          "grain:%.2f "
                          "scope:%.2f "
                          %(tGuess,tGuessSd,pThreshold,beta,delta,gamma,grain,scope))
        self.logger.write("Quest trials is set to %d" %self.trialsDesired)
        
    def run(self, sed):
        self.logger.write("="*36)
        self.logger.write("QUEST for sensory eye dominance(SED)")
        self.logger.write("Control eye contrast: %.2f" %self.control_contrast)
        self.logger.write("Tested eye: %s" %sed.get_test_eye())
        self.logger.write("="*36)
        sed.update_control_contrast(self.control_contrast)
        for k in range(self.trialsDesired):
            # Get recommended level.  Choose your favorite algorithm.
            tTest = self.quest_obj.quantile()
            rand_contrast = 10**tTest + random.choice([-0.1,0,0.1])
            if rand_contrast <= 0:
                tTest = -4.0
            else:
                tTest = math.log10(rand_contrast)
            if tTest > 0: tTest = 0
            test_contrast = 10**tTest
            #tTest=q.mean()
            #tTest=q.mode()
            sed.update_orientation()
            sed.update_test_contrast(test_contrast)
            test_ori = sed.get_test_eye_orientation()
            self.logger.write("Trial %d :\n"
                  "\ttest eye %s, contrast %f\n"
                  "\ttest eye orientation %s"%(k, sed.get_test_eye(), test_contrast, test_ori))
            key_response = sed.run()
            response = key_response == test_ori
            if response:
                self.logger.write("\tobserver reports test eye")
            else:
                self.logger.write("\tobserver reports control eye")
            # Update the pdf
            self.quest_obj.update(tTest, int(response))
        
        # Get final estimate.
        t = self.quest_obj.mean()
        sd = self.quest_obj.sd()
        self.logger.write('\n%s eye balanced contrast is %4.2f +/- %.2f'%(sed.get_test_eye(), 10**t, sd))
        #t=QuestMode(q);
        #print 'Mode threshold estimate is %4.2f'%t
    
        self.logger.write('\nQuest beta analysis. Beta controls the steepness of the Weibull function.\n')
        self.quest_obj.beta_analysis(self.logger)
        self.logger.write_filestamp()
コード例 #6
0
ファイル: stereo.py プロジェクト: chrox/RealTimeElectrophy
class Staircase(object):
    def __init__(self, subject, pre_fix):
        self.logger = Logger(subject, pre_fix)

        self.trialsDesired = 50
        startVal = 0.5
        nReversals = 10
        stepSizes = [0.03, 0.01, 0.01, 0.005, 0.005, 0.002, 0.001]
        nTrials = 50
        nUp = 1
        nDown = 3
        stepType = "lin"
        minVal = 0
        maxVal = 0.5

        self.staircase_obj = StaircaseObject(startVal, nReversals, stepSizes,
                                             nTrials, nUp, nDown, stepType,
                                             minVal, maxVal)

        self.logger.write("Staircase for Stereo Threshold measurement")
        self.logger.write("Staircase object is initiated with "
                          "startVal:%.2f "
                          "nReversals:%.2f "
                          "stepSizes:%s "
                          "nTrials:%.2f "
                          "nUp:%.2f "
                          "nDown:%.2f "
                          "minVal:%.2f "
                          "maxVal:%.2f " %
                          (startVal, nReversals, stepSizes, nTrials, nUp,
                           nDown, minVal, maxVal))
        self.logger.write("Staircase trials is set to %d" % nTrials)

    def run(self, disparity):
        self.logger.write("=" * 36)
        self.logger.write("Staircase for Stereo Threshold measurement")
        self.logger.write("=" * 36)
        # disc demo
        disparity.set_disparity(0.1)
        disparity.demo()
        for i, disp in enumerate(self.staircase_obj):
            disparity.set_disparity(disp)
            response = disparity.run()

            interval = disparity.get_cross_interval()  # [1,2]
            self.logger.write("Trial %d :\n"
                              "\tdisparity %.2f,"
                              "\tcross at interval %d" % (i, disp, interval))

            self.logger.write("\tobserver reports %s" % response)
            # Update the pdf
            self.staircase_obj.update(int(response))

        # Get final estimate.
        t = self.staircase_obj.mean(final=6)
        self.logger.write('\nmean of final 6 reversals = %.3f\n' % t)
        self.logger.write_filestamp()
コード例 #7
0
ファイル: sed.py プロジェクト: chrox/RealTimeElectrophy
class Quest(object):
    def __init__(self, subject, pre_fix, contrast):
        self.logger = Logger(subject, pre_fix)
        self.control_contrast = contrast

        tGuess = math.log10(self.control_contrast)
        tGuessSd = 2.0  # sd of Gaussian before clipping to specified range
        pThreshold = 0.82
        #beta = 3.5
        beta = 4.0
        delta = 0.01
        gamma = 0.5
        grain = 0.01
        scope = 3

        self.quest_obj = QuestObject(tGuess=tGuess,
                                     tGuessSd=tGuessSd,
                                     pThreshold=pThreshold,
                                     beta=beta,
                                     delta=delta,
                                     gamma=gamma,
                                     grain=grain,
                                     scope=scope)
        self.trialsDesired = 50

        self.logger.write("QUEST for Sensory Eye Dominance(SED) measurement")
        self.logger.write(
            "Quest object is initiated with "
            "tGuess:%.2f "
            "tGuessSd:%.2f "
            "pThreshold:%.2f "
            "beta:%.2f "
            "delta:%.2f "
            "gamma:%.2f "
            "grain:%.2f "
            "scope:%.2f " %
            (tGuess, tGuessSd, pThreshold, beta, delta, gamma, grain, scope))
        self.logger.write("Quest trials is set to %d" % self.trialsDesired)

    def run(self, sed):
        self.logger.write("=" * 36)
        self.logger.write("QUEST for sensory eye dominance(SED)")
        self.logger.write("Control eye contrast: %.2f" % self.control_contrast)
        self.logger.write("Tested eye: %s" % sed.get_test_eye())
        self.logger.write("=" * 36)
        sed.update_control_contrast(self.control_contrast)
        for k in range(self.trialsDesired):
            # Get recommended level.  Choose your favorite algorithm.
            tTest = self.quest_obj.quantile()
            rand_contrast = 10**tTest + random.choice([-0.1, 0, 0.1])
            if rand_contrast <= 0:
                tTest = -4.0
            else:
                tTest = math.log10(rand_contrast)
            if tTest > 0: tTest = 0
            test_contrast = 10**tTest
            #tTest=q.mean()
            #tTest=q.mode()
            sed.update_orientation()
            sed.update_test_contrast(test_contrast)
            test_ori = sed.get_test_eye_orientation()
            self.logger.write("Trial %d :\n"
                              "\ttest eye %s, contrast %f\n"
                              "\ttest eye orientation %s" %
                              (k, sed.get_test_eye(), test_contrast, test_ori))
            key_response = sed.run()
            response = key_response == test_ori
            if response:
                self.logger.write("\tobserver reports test eye")
            else:
                self.logger.write("\tobserver reports control eye")
            # Update the pdf
            self.quest_obj.update(tTest, int(response))

        # Get final estimate.
        t = self.quest_obj.mean()
        sd = self.quest_obj.sd()
        self.logger.write('\n%s eye balanced contrast is %4.2f +/- %.2f' %
                          (sed.get_test_eye(), 10**t, sd))
        #t=QuestMode(q);
        #print 'Mode threshold estimate is %4.2f'%t

        self.logger.write(
            '\nQuest beta analysis. Beta controls the steepness of the Weibull function.\n'
        )
        self.quest_obj.beta_analysis(self.logger)
        self.logger.write_filestamp()
コード例 #8
0
ファイル: stereo.py プロジェクト: chrox/RealTimeElectrophy
class Staircase(object):
    def __init__(self, subject, pre_fix):
        self.logger = Logger(subject, pre_fix)
        
        self.trialsDesired = 50
        startVal = 0.5
        nReversals = 10
        stepSizes = [0.03, 0.01, 0.01, 0.005, 0.005, 0.002, 0.001]
        nTrials = 50
        nUp = 1
        nDown = 3
        stepType = "lin"
        minVal = 0
        maxVal = 0.5
        
        self.staircase_obj = StaircaseObject(
                startVal, nReversals, stepSizes,
                nTrials, nUp, nDown,
                stepType, minVal, maxVal)
        
        self.logger.write("Staircase for Stereo Threshold measurement")
        self.logger.write("Staircase object is initiated with "
                          "startVal:%.2f "
                          "nReversals:%.2f "
                          "stepSizes:%s "
                          "nTrials:%.2f "
                          "nUp:%.2f "
                          "nDown:%.2f "
                          "minVal:%.2f "
                          "maxVal:%.2f "
                          %(startVal,nReversals,stepSizes,nTrials,nUp,nDown,minVal,maxVal))
        self.logger.write("Staircase trials is set to %d" %nTrials)
        
    def run(self, disparity):
        self.logger.write("="*36)
        self.logger.write("Staircase for Stereo Threshold measurement")
        self.logger.write("="*36)
        # disc demo
        disparity.set_disparity(0.1)
        disparity.demo()
        for i, disp in enumerate(self.staircase_obj):
            disparity.set_disparity(disp)
            response = disparity.run()
            
            interval = disparity.get_cross_interval()  # [1,2]
            self.logger.write("Trial %d :\n"
                  "\tdisparity %.2f,"
                  "\tcross at interval %d" %(i, disp, interval))
            
            self.logger.write("\tobserver reports %s" %response)
            # Update the pdf
            self.staircase_obj.update(int(response))
        
        # Get final estimate.
        t = self.staircase_obj.mean(final=6)
        self.logger.write('\nmean of final 6 reversals = %.3f\n' %t)
        self.logger.write_filestamp()