OPI (version 1.6)

FT: Full Threshold

Description

FT begins with a 4-2dB staircase at level est. If the final estimate (last seen) is more than 4dB away from est, a second 4-2 staircase is completed beginning at the estimate returned from the first.

Usage

FT(est = 25, instRange = c(0, 40), verbose = FALSE, makeStim, ...)
FT.start(est=25, instRange=c(0,40), makeStim, ...)
FT.step(state, nextStim=NULL)
FT.stop(state) 
FT.final(state)
FT.final.details(state)

Arguments

est

Starting estimate in dB

instRange

Dynamic range of the instrument c(min,max) in dB

verbose

True if you want each presentation printed

makeStim

A function that takes a dB value and numPresentations and returns an OPI datatype ready for passing to opiPresent

...

Extra parameters to pass to the opiPresent function

state

Current state of the FT returned by FT.start and FT.step.

nextStim

A valid object for opiPresent to use as its nextStim.

Value

• Single location{ Returns a list containing
  • npres
  { Total number of presentations}
• respSeq
  Response sequence stored as a list of (seen,dB) pairs
• first
  First staircase estimate in dB
• final
  Final threshold estimate in dB
• }

subsection

Multilple locations

code

Min

itemize

• final:

item

• currentLevel:
• lastSeen:
• lastResponse:
• firstStairResult:
• secondStairResult:
• finished:
• numberOfReversals:
• currSeenLimit:
• currNotSeenLimit:
• numPresentations:
• stimuli:
• responses:
• responseTimes:
• resp:
• first:
• stopReason:
• np:

Details

This is an implementation of a 4-2 1-up 1-down staircase as implemented in the first Humphrey Field Analyzer. The initial staircase starts at est and proceeds in steps of 4dB until the first reversal, and 2dB until the next reversal. The last seen stimulus is taken as the threshold value. If, after the first staircase, the threshold is more than 4 dB away from the starting point, then a second staircase is initiated with a starting point equal to the threshold found with the first staircase.

Note this function will repeatedly call opiPresent for a stimulus until opiPresent returns NULL (ie no error occured).

If more than one FT is to be interleaved (for example, testing multiple locations), then the FT.start, FT.step, FT.stop and FT.final calls can maintain the state of the FT after each presentation, and should be used. If only a single FT is required, then the simpler FT can be used. See examples below.

References

Please cite: A. Turpin, P.H. Artes and A.M. McKendrick "The Open Perimetry Interface: An enabling tool for clinical visual psychophysics", Journal of Vision 12(11) 2012.

H. Bebie, F. Fankhauser and J. Spahr. "Static perimetry: strategies", Acta Ophthalmology 54 1976.

C.A. Johnson, B.C. Chauhan, and L.R. Shapiro. "Properties of staircase procedures for estimating thresholds in automated perimetry", Investagative Ophthalmology and Vision Science 33 1993.

http://perimetry.org/OPI

See Also

dbTocd, opiPresent

Examples

# Stimulus is Size III white-on-white as in the HFA
makeStim <- function(db, n) { 
    s <- list(x=9, y=9, level=dbTocd(db), size=0.43, color="white",
             duration=200, responseWindow=1500)
    class(s) <- "opiStaticStimulus"

    return(s)
}
chooseOpi("SimHenson")
if (!is.null(opiInitialize(type="C", cap=6)))
    stop("opiInitialize failed")

result <- FT(makeStim=makeStim, tt=30, fpr=0.15, fnr=0.01)

if (!is.null(opiClose()))
    warning("opiClose() failed")

    ##############################################
    # This section is for multiple FTs
    ##############################################
makeStimHelper <- function(db,n, x, y) {  # returns a function of (db,n)
    ff <- function(db, n) db+n

    body(ff) <- substitute(
        {s <- list(x=x, y=y, level=dbTocd(db), size=0.43, color="white",
                  duration=200, responseWindow=1500)
         class(s) <- "opiStaticStimulus"
         return(s)
        }
        , list(x=x,y=y))
    return(ff)
}

    # List of (x, y, true threshold) triples
locations <- list(c(9,9,30), c(-9,-9,32), c(9,-9,31), c(-9,9,33))

    # Setup starting states for each location
states <- lapply(locations, function(loc) {
    FT.start( makeStim=makeStimHelper(db,n,loc[1],loc[2]),
              tt=loc[3], fpr=0.03, fnr=0.01)
})

    # Loop through until all states are "stop"
while(!all(st <- unlist(lapply(states, FT.stop)))) {
    i <- which(!st)                         # choose a random, 
    i <- i[runif(1, min=1, max=length(i))]  # unstopped state
    r <- FT.step(states[[i]])               # step it
    states[[i]] <- r$state                  # update the states
}

finals <- lapply(states, FT.final)    # get final estimates of threshold
for(i in 1:length(locations)) {
    cat(sprintf("Location (%+2d,%+2d) ",locations[[i]][1], locations[[i]][2]))
    cat(sprintf("has threshold %4.2f
", finals[[i]]))
}

if (!is.null(opiClose()))
    warning("opiClose() failed")