Method calculateSpecmap

src_generators/specularmapgenerator.cpp:34–108

}

QImage SpecularmapGenerator::calculateSpecmap(const QImage &input, double scale, double contrast) {
    QImage result(input.width(), input.height(), QImage::Format_ARGB32);
    
    //generate contrast lookup table
    unsigned short contrastLookup[256];
    double newValue = 0;
    
    for(int i = 0; i < 256; i++) {
        newValue = (double)i;
        newValue /= 255.0;
        newValue -= 0.5;
        newValue *= contrast;
        newValue += 0.5;
        newValue *= 255;
    
        if(newValue < 0)
            newValue = 0;
        if(newValue > 255)
            newValue = 255;
        
        contrastLookup[i] = (unsigned short)newValue;
    }
    
    // This is outside of the loop because the multipliers are the same for every pixel
    double multiplierSum = (redMultiplier + greenMultiplier + blueMultiplier + alphaMultiplier);
    if(multiplierSum == 0.0)
        multiplierSum = 1.0;

    #pragma omp parallel for  // OpenMP
    //for every row of the image
    for(int y = 0; y < result.height(); y++) {
        QRgb *scanline = (QRgb*) result.scanLine(y);

        //for every column of the image
        for(int x = 0; x < result.width(); x++) {
            double intensity = 0.0;

            const QColor pxColor = QColor(input.pixel(x, y));

            const double r = pxColor.redF() * redMultiplier;
            const double g = pxColor.greenF() * greenMultiplier;
            const double b = pxColor.blueF() * blueMultiplier;
            const double a = pxColor.alphaF() * alphaMultiplier;

            if(mode == IntensityMap::AVERAGE) {
                //take the average out of all selected channels
                intensity = (r + g + b + a) / multiplierSum;
            }
            else if(mode == IntensityMap::MAX) {
                //take the maximum out of all selected channels
                const double tempMaxRG = std::max(r, g);
                const double tempMaxBA = std::max(b, a);
                intensity = std::max(tempMaxRG, tempMaxBA);
            }

            //apply scale (brightness)
            intensity *= scale;