FractControllerContrast.j

/*
This file is part of FrACT10, a vision test battery.
© 2021 Michael Bach, bach@uni-freiburg.de, <https://michaelbach.de>

FractControllerContrast.j

Created by Bach on 2020-09-02
*/

@import "FractController.j"
@import "Dithering.j"


@implementation FractControllerContrast: FractController {
    float stimStrengthInDeviceunitsUnquantised;
}

- (CPString) composeExportString {return [self contrastComposeExportString];}


- (void) modifyThresholderStimulus {
    if (iTrial === 1) //make the first more visible
        stimStrengthInThresholderUnits = Math.min(stimStrengthInThresholderUnits + 0.3, 1);
    if ([Settings contrastHasEasyTrials]) //don't forget bonus
        [self modifyThresholderStimulusWithBonus];
}


- (void) calculateForeBackColors {
    let gray1 = [MiscLight lowerLuminanceFromContrastLogCSWeber: stimStrengthInDeviceunits];
    gray1 = [MiscLight devicegrayFromLuminance: gray1];
    let gray2 = [MiscLight upperLuminanceFromContrastLogCSWeber: stimStrengthInDeviceunits];
    gray2 = [MiscLight devicegrayFromLuminance: gray2];
    if (![Settings isContrastDarkOnLight]) {
        [gray1, gray2] = [gray2, gray1]; //"modern" swapping of variables
    }
    gColorFore = [MiscLight colorFromGreyBitStealed: gray1]; //console.info(gColorFore);
    gColorBack = [MiscLight colorFromGreyBitStealed: gray2]; //console.info(gColorBack);
    colorForeUndithered = gColorFore;  colorBackUndithered = gColorBack;
    stimStrengthInDeviceunitsUnquantised = stimStrengthInDeviceunits;

    if ([Settings isContrastDithering]) {
        gColorFore = [CPColor colorWithPatternImage: [Dithering image3x3withGray: gray1]];
        gColorBack = [CPColor colorWithPatternImage: [Dithering image3x3withGray: gray2]];
    }
}


//Strategy: draw fixmark, delay (onTimeoutFixMark) and draw optotype, erasing fixmark.
//With eccentricity: Need to draw again right after optotype so it seamlessly stays put
//No marked eccentricity: don't draw it again
- (void) drawFixMark3 { //check marked eccentricity is set, otherwise don't draw it
    const eccRadiusInPix = Math.sqrt(xEccInPix * xEccInPix + yEccInPix * yEccInPix);
    if ((strokeSizeInPix * 4) > eccRadiusInPix) return; //we don't want overlap between fixmark and optotype
    [self drawFixMark2];
}
- (void) drawFixMark2 {
    CGContextSaveGState(cgc);
    CGContextSetStrokeColor(cgc, [CPColor colorWithRed: 0 green: 0 blue: 1 alpha: 0.7]);
    CGContextSetLineWidth(cgc, 0.5);
    CGContextTranslateCTM(cgc,  +xEccInPix, +yEccInPix); //counter eccentricity
    [optotypes strokeStarAtX: 0 y: 0 size: strokeSizeInPix * 3];
    CGContextRestoreGState(cgc);
}
- (void) drawFixMark {
    let t = [Settings contrastTimeoutFixmark] / 1000; //ms → seconds
    if ([Settings contrastShowFixMark] && (gCurrentTestID !== kTestContrastDitherUnittest)) {
        [self drawFixMark2];
        timerFixMark = [CPTimer scheduledTimerWithTimeInterval: t target:self selector:@selector(onTimeoutFixMark:) userInfo:nil repeats:NO];
    } else {
        t = 0.02;
    }
    timerFixMark = [CPTimer scheduledTimerWithTimeInterval: t target:self selector:@selector(onTimeoutFixMark:) userInfo:nil repeats:NO];
    discardKeyEntries = NO; //now allow responding
}
- (void) onTimeoutFixMark: (CPTimer) timer { //console.info("FractController>onTimeoutFixCross");
    state = kStateDrawFore2;
    [[[self window] contentView] setNeedsDisplay: YES];
}


- (void) runStart { //console.info("FractControllerContrast>runStart");
    [super runStart];
    [gAppController setCurrentTestResultUnit: "logCSWeber"];
}


//this manages stuff after the optotypes have been drawn
- (void) drawStimulusInRect: (CGRect) dirtyRect { //console.info("FractControllerContrast>drawStimulusInRect");
    if ([Settings isContrastDithering]) {
        stimStrengthInDeviceunits = stimStrengthInDeviceunitsUnquantised;
    }
    [TrialHistoryManager setValue: stimStrengthInDeviceunits];

    if (([Settings contrastCrowdingType] > 0) && (state === kStateDrawFore2) &&
        (!([kTestAcuityLineByLine, kTestAcuityVernier, kTestContrastG].includes(gCurrentTestID)))) { //don't do crowding with these
        CGContextSaveGState(cgc);
        CGContextTranslateCTM(cgc, viewWidthHalf, viewHeightHalf); //origin to center
        CGContextTranslateCTM(cgc, -xEccInPix, -yEccInPix);
        const crowdingGap = [self crowdingGapFromStrokeWidth: strokeSizeInPix];
        const distance4bars = crowdingGap + (0.5 + 2.5) * strokeSizeInPix;
        const distance4optotypes = crowdingGap + 5 * strokeSizeInPix;
        CGContextSetLineWidth(cgc, strokeSizeInPix);
        CGContextSetStrokeColor(cgc, gColorFore);
        switch ([Settings contrastCrowdingType]) {
            case 0:  break; //should not occur here anyway
            case 1: //flanking bars
                const length2 = strokeSizeInPix * 2.5;
                [optotypes strokeVLineAtX: -distance4bars y0: -length2 y1: length2];
                [optotypes strokeVLineAtX: distance4bars y0: -length2 y1: length2];
                break;
            case 2: //flanking rings
                for (let i = -1; i <= 1; i++) { //console.info(i);
                    const tempX = i * distance4optotypes;
                    CGContextTranslateCTM(cgc,  -tempX, 0);
                    if (i !== 0)  [optotypes drawLandoltWithStrokeInPx: strokeSizeInPix landoltDirection: -1];
                    CGContextTranslateCTM(cgc,  +tempX, 0);
                }  break;
            case 3: //surounding bars
                const length4 = strokeSizeInPix * 4;
                CGContextSetLineCap(cgc,  kCGLineCapRound);
                [optotypes strokeVLineAtX: -distance4bars y0: -length4 y1: length4];
                [optotypes strokeVLineAtX: distance4bars y0: -length4 y1: length4];
                [optotypes strokeHLineAtX0: -length4 y: -distance4bars x1: length4];
                [optotypes strokeHLineAtX0: -length4 y: distance4bars x1: length4];
                break;
            case 4: //surounding ring: gap + 2.5 strokes + ½ stroke for stroke width
                [optotypes strokeCircleAtX: 0 y: 0 radius: distance4bars];
                break;
            case 5: //surrounding square
                const frameSizeX2 = 2 * distance4bars, frameSize = distance4bars;
                CGContextStrokeRect(cgc, CGRectMake(-frameSize, -frameSize, frameSizeX2, frameSizeX2));
                break;
            case 6: //console.info("row of optotypes");
                let rowAlternatives = [[AlternativesGenerator alloc] initWithNumAlternatives: nAlternatives andNTrials: 5 obliqueOnly: NO];
                for (let i = -2; i <= 2; i++) {
                    const tempX = i * distance4optotypes;
                    CGContextTranslateCTM(cgc, -tempX, 0);
                    if (i !== 0)  {
                        let directionInRow = [rowAlternatives nextAlternative];
                        if (directionInRow === [alternativesGenerator currentAlternative])
                            directionInRow = [rowAlternatives nextAlternative];
                        switch (gCurrentTestID) {
                            case kTestContrastLetters:
                                [optotypes drawLetterNr: directionInRow withStrokeInPx: strokeSizeInPix];  break;
                            case kTestContrastE:
                                [optotypes tumblingEWithStrokeInPx: strokeSizeInPix direction: directionInRow];  break;
                            default:
                                [optotypes drawLandoltWithStrokeInPx: strokeSizeInPix landoltDirection: directionInRow];
                        }
                    }
                    CGContextTranslateCTM(cgc, +tempX, 0);
                }  break;
        }
        CGContextRestoreGState(cgc);
    }
    [super drawStimulusInRect: dirtyRect];
}


- (void) runEnd { //console.info("FractControllerContrast>runEnd");
    if (iTrial < nTrials) { //premature end
        [gAppController setResultStringFieldTo: gAbortMessage];
    } else {
        stimStrengthInDeviceunits = Math.min(stimStrengthInDeviceunits, gMaxResultLogCSWeber);
        gTestDetails[td_resultValue] = stimStrengthInDeviceunits;
        [gAppController setResultStringFieldTo: [self contrastComposeResultString]];

    }
    [super runEnd];
}


/////////////////////////CONTRAST UTILs
/*
basic flow:
 Thresholder → thresholderunits
 thresholderunits → deviceunits (logCSWeber)
 deviceunits → upper/lower luminance, considering gamma → discrete values for [CPColor colorWithWhite] (0…255)
 present stimulus
 stimStrengthInDeviceunits → thresholderunits (currently ignoring gamma because "locally everything is linear")
 thresholderunits + correctness → Thresholder
 

//contrast: 0.1 … 100, thresholder: 0 … 1
//deviceUnits are in logCSWeber for all contrast tests; for gratings that is converted to Michelson%
//logCSW: 2 … 0, thresholder: 0 … 1 */

- (float) getCurrentContrastMichelsonPercent {
    return [MiscLight contrastMichelsonPercentFromColor1: colorForeUndithered color2: colorBackUndithered];
}
/*- (float) getCurrentContrastWeberPercent {
    return [MiscLight contrastWeberPercentFromMichelsonPercent: [self getCurrentContrastMichelsonPercent]];
}*/
//Problem here: 0% weber contrast corresponds to infinite logCSWeber.
//But since the latter is clamped at kMaxAllowedLogCSWeber, after rounding this will still read 0%. Solved.
- (float) getCurrentContrastLogCSWeber {
    const michelsonPercent = [self getCurrentContrastMichelsonPercent];
    const weberPercent = [MiscLight contrastWeberPercentFromMichelsonPercent: michelsonPercent];
    return [MiscLight contrastLogCSWeberFromWeberPercent: weberPercent];
}


- (float) stimDeviceunitsFromThresholderunits: (float) thresholderunit { //console.info("FractControllerContrast>stimDeviceunitsFromThresholderunits");
    const logCSWMaximal = [Settings contrastMaxLogCSWeber];
    const deviceVal = logCSWMaximal - logCSWMaximal * thresholderunit; //logCSWMinimal = 0 anyway
    return deviceVal;
}
- (float) stimThresholderunitsFromDeviceunits: (float) d { //console.info("FractControllerContrast>stimThresholderunitsFromDeviceunits");
    //console.info("d: ", d, ",  retVal: ", retVal)
    const logCSWMaximal = [Settings contrastMaxLogCSWeber];
    const retVal = (logCSWMaximal - d) / logCSWMaximal
    return retVal;
}
- (void) unittestContrastDeviceThresholdConversion {
    for (let i = 0; i <= 1.0; i += 0.1) {
        const d = [self contrastStimDeviceunitsFromThresholderunits: i];
        console.info("threshh: ", i, ", devUnits: ", d, ", threshh: ", [self stimThresholderunitsFromDeviceunits: d]);
    }
}


- (CPString) contrastComposeTrialInfoString {
    let s = "trial: " + iTrial + "/" + nTrials;
    s +=  ", contrast: " + [Misc stringFromNumber: [MiscLight contrastWeberPercentFromLogCSWeber: stimStrengthInDeviceunits] decimals: 2 localised: YES] + "%";
    s += ", logCSW: " + [Misc stringFromNumber: stimStrengthInDeviceunits decimals: 2 localised: YES];
    s += ", alternative: " + [alternativesGenerator currentAlternative];
    return s;
}


- (CPString) contrastComposeResultString { //console.info("contrastComposeResultString");
    //console.info("rangeLimitStatus: ", rangeLimitStatus);
    rangeLimitStatus = kRangeLimitOk;
    if (stimStrengthInDeviceunits >= gMaxResultLogCSWeber) { //todo: do this while testing
        rangeLimitStatus = kRangeLimitValueAtCeiling;
    }
    let s = "Contrast threshold: " + CPCarriageReturnCharacter;
    s += [self rangeStatusIndicatorStringInverted: YES];
    s += [Misc stringFromNumber: stimStrengthInDeviceunits decimals: 2 localised: YES];
    s += " logCS(Weber) ≙ ";
    s += [self rangeStatusIndicatorStringInverted: NO];
    s += [Misc stringFromNumber: [MiscLight contrastWeberPercentFromLogCSWeber: stimStrengthInDeviceunits] decimals: 2 localised: YES];
    s += "%";
    return s;
}


- (CPString) contrastComposeExportString { //console.info("FractController>contrastComposeExportString");
    if (gAppController.runAborted) return "";
    let s = [self generalComposeExportString];
    const nDigits = 3;
    s += CPTabCharacter + "value" + CPTabCharacter + [Misc stringFromNumber: stimStrengthInDeviceunits decimals: nDigits localised: YES];
    s += CPTabCharacter + "unit1" + CPTabCharacter + gAppController.currentTestResultUnit
    s += CPTabCharacter + "distanceInCm" + CPTabCharacter + [Misc stringFromNumber: [Settings distanceInCM] decimals: 2 localised: YES];
    s += CPTabCharacter + "diameter" + CPTabCharacter + [Misc stringFromNumber: [Settings contrastOptotypeDiameter] decimals: 2 localised: YES];
    s += CPTabCharacter + "unit2" + CPTabCharacter + "arcmin";
    s += CPTabCharacter + "nTrials" + CPTabCharacter + [Misc stringFromNumber: nTrials decimals: 0 localised: YES];
    s += CPTabCharacter + "rangeLimitStatus" + CPTabCharacter + rangeLimitStatus;
    s += CPTabCharacter + "crowding" + CPTabCharacter + 0; //does not apply, but let's not NaN this
    return [self generalComposeExportStringFinalize: s];
}


@end