A C++ Approach to Optimizing Color Contrast

Introduction

Color plays a crucial role in design and visual communication. Ensuring optimal contrast and luminance between colors is vital for accessibility, particularly for individuals with visual impairments. The following functions—CalculateLuminance, CalculateContrast, BrightenColor, DarkenColor, and AdjustContrast—are essential tools for adjusting and evaluating color properties.

CalculateLuminance

The CalculateLuminance function transforms a given color (specified in the Windows GDI COLORREF format) into its corresponding luminance value. This involves converting color components to the sRGB color space, applying gamma correction, and calculating luminance using standardized coefficients. Luminance is a measure of the perceived brightness of a color and is crucial for assessing visual contrast.

CalculateContrast

The CalculateContrast function compares the luminance of two colors and computes the contrast ratio between them. The result is a numeric value representing the difference in brightness. This function is integral for evaluating color combinations and ensuring readability or visibility, with higher contrast ratios generally indicating better accessibility.

BrightenColor and DarkenColor

These functions—BrightenColor and DarkenColor—adjust the intensity of a given color by increasing or decreasing its RGB components. They allow for controlled color modification, useful for improving legibility by lightening or darkening text or graphic elements.

AdjustContrast

The AdjustContrast function is designed to enhance the contrast of a variable color relative to a fixed color, ensuring a specified target contrast ratio. It dynamically adjusts the brightness of the variable color, progressively lightening or darkening it until the desired contrast is achieved. This is particularly beneficial for adhering to accessibility standards, such as the WCAG recommendation of a minimum 4.5:1 contrast ratio for text and images.

Wrap-up

These functions are a helpful toolkit for C++ developers aiming to create visually accessible content. By leveraging these tools, one can fine-tune color combinations, improve readability, and ensure a more inclusive user experience, catering to a diverse audience with varying visual needs.

Source Code

double CalculateLuminance(COLORREF color) {
    // Convert color components to the sRGB colorspace
    double RsRGB = GetRValue(color) / 255.0;
    double GsRGB = GetGValue(color) / 255.0;
    double BsRGB = GetBValue(color) / 255.0;

    // Apply gamma correction
    double R = (RsRGB <= 0.04045) ? RsRGB / 12.92 : pow((RsRGB + 0.055) / 1.055, 2.4);
    double G = (GsRGB <= 0.04045) ? GsRGB / 12.92 : pow((GsRGB + 0.055) / 1.055, 2.4);
    double B = (BsRGB <= 0.04045) ? BsRGB / 12.92 : pow((BsRGB + 0.055) / 1.055, 2.4);

    // Calculate relative luminance using the sRGB coefficients
    return 0.2126 * R + 0.7152 * G + 0.0722 * B;
}

double CalculateContrast(COLORREF color1, COLORREF color2) {
    double luminance1 = CalculateLuminance(color1);
    double luminance2 = CalculateLuminance(color2);

    double contrast = (max(luminance1, luminance2) + 0.05) / (min(luminance1, luminance2) + 0.05);
    return contrast;
}

COLORREF BrightenColor(COLORREF color, int step) {
    int r = min(255, GetRValue(color) + step);
    int g = min(255, GetGValue(color) + step);
    int b = min(255, GetBValue(color) + step);

    return RGB(r, g, b);
}

COLORREF DarkenColor(COLORREF color, int step) {
    int r = max(0, GetRValue(color) - step);
    int g = max(0, GetGValue(color) - step);
    int b = max(0, GetBValue(color) - step);

    return RGB(r, g, b);
}

COLORREF AdjustContrast(COLORREF fixedColor, COLORREF variableColor) {
    double targetContrast = 4.5; // Adjust this value based on your requirements
    int stepSize = 5; // Adjust this step size based on your preferences
    COLORREF currentColor(variableColor);

    double initialContrast = CalculateContrast(fixedColor, currentColor);

    // If the initial contrast is sufficient, return the original color
    if (initialContrast >= targetContrast) {
        return currentColor;
    }

    // Brighten the color until it's white and check contrast at each step
    while (initialContrast < targetContrast && GetRValue(currentColor) < 255) {
        currentColor = BrightenColor(currentColor, stepSize);
        double currentContrast = CalculateContrast(fixedColor, currentColor);

        if (currentContrast >= targetContrast) {
            return currentColor;
        }
    }

    // Reset to the original color
    currentColor = variableColor;

    // Darken the color until it's black and check contrast at each step
    while (initialContrast < targetContrast && GetRValue(currentColor) > 0) {
        currentColor = DarkenColor(currentColor, stepSize);
        double currentContrast = CalculateContrast(fixedColor, currentColor);

        if (currentContrast >= targetContrast) {
            return currentColor;
        }
    }

    // Return the original color if all else fails
    return variableColor;
}