[FIXED] Implementierung von Unsharp -Masken mit OpenCV

Ausgabe

Ich möchte eine unscharfe Maske wie Adobe Photoshop anwenden, ich kenne diese Antwort, aber sie ist nicht so scharf wie Photoshop.

Photoshop hat 3 Parameter im Smart Sharpen-Dialog: Betrag, Radius, Rauschen reduzieren; Ich möchte sie alle umsetzen.

Dies ist der Code, den ich laut verschiedenen Quellen in SO geschrieben habe. Aber das Ergebnis ist in einigen Stufen gut (“blurred”, “unsharpMask”, “highContrast”), aber in der letzten Stufe (“retval”) ist das Ergebnis nicht gut.

Wo liege ich falsch, was sollte ich verbessern?

Ist es möglich, den folgenden Algorithmus in Bezug auf die Leistung zu verbessern?

#include "opencv2/opencv.hpp"
#include "fstream"
#include "iostream"
#include <chrono>

using namespace std;
using namespace cv;

// from https://docs.opencv.org/3.4/d3/dc1/tutorial_basic_linear_transform.html
void increaseContrast(Mat img, Mat* dst, int amountPercent)
{
    *dst = img.clone();
    double alpha = amountPercent / 100.0;
    *dst *= alpha;
}

// from https://stackoverflow.com/a/596243/7206675
float luminanceAsPercent(Vec3b color)
{
    return (0.2126 * color[2]) + (0.7152 * color[1]) + (0.0722 * color[0]);
}

// from https://stackoverflow.com/a/2938365/7206675
Mat usm(Mat original, int radius, int amountPercent, int threshold)
{
    // copy original for our return value
    Mat retval = original.clone();

    // create the blurred copy
    Mat blurred;
    cv::GaussianBlur(original, blurred, cv::Size(0, 0), radius);

    cv::imshow("blurred", blurred);
    waitKey();

    // subtract blurred from original, pixel-by-pixel to make unsharp mask
    Mat unsharpMask;
    cv::subtract(original, blurred, unsharpMask);

    cv::imshow("unsharpMask", unsharpMask);
    waitKey();

    Mat highContrast;
    increaseContrast(original, &highContrast, amountPercent);

    cv::imshow("highContrast", highContrast);
    waitKey();

    // assuming row-major ordering
    for (int row = 0; row < original.rows; row++) 
    {
        for (int col = 0; col < original.cols; col++) 
        {
            Vec3b origColor = original.at<Vec3b>(row, col);
            Vec3b contrastColor = highContrast.at<Vec3b>(row, col);

            Vec3b difference = contrastColor - origColor;
            float percent = luminanceAsPercent(unsharpMask.at<Vec3b>(row, col));

            Vec3b delta = difference * percent;

            if (*(uchar*)&delta > threshold) {
                retval.at<Vec3b>(row, col) += delta;
                //retval.at<Vec3b>(row, col) = contrastColor;
            }
        }
    }

    return retval;
}

int main(int argc, char* argv[])
{
    if (argc < 2) exit(1);
    Mat mat = imread(argv[1]);
    mat = usm(mat, 4, 110, 66);
    imshow("usm", mat);
    waitKey();
    //imwrite("USM.png", mat);
}

Original Bild:

Verschwommene Bühne – Scheinbar gut:

UnsharpMask-Stufe – Scheinbar gut:

HighContrast Stufe – Scheinbar gut:

Ergebnisstadium meines Codes – Sieht schlecht aus!

Ergebnis von Photoshop – Ausgezeichnet!

Lösung

First of all, judging by the artefacts that Photoshop left on the borders of the petals, I’d say that it applies the mask by using a weighted sum between the original image and the mask, as in the answer you tried first.

I modified your code to implement this scheme and I tried to tweak the parameters to get as close as the Photoshop result, but I couldn’t without creating a lot of noise. I wouldn’t try to guess what Photoshop is exactly doing (I would definitely like to know), however I discovered that it is fairly reproducible by applying some filter on the mask to reduce the noise. The algorithm scheme would be:

blurred = blur(image, Radius)
mask = image - blurred
mask = some_filter(mask)
sharpened = (mask < Threshold) ? image : image - Amount * mask

I implemented this and tried using basic filters (median blur, mean filter, etc) on the mask and this is the kind of result I can get:

Das ist etwas lauter als das Photoshop-Bild, aber meiner Meinung nach nah genug an dem, was Sie wollten.

Auf einer anderen Anmerkung hängt es natürlich von der Verwendung ab, die Sie für Ihren Filter haben, aber ich denke, dass die Einstellungen, die Sie in Photoshop verwendet haben, zu stark sind (Sie haben große Überschwinger in der Nähe von Blütenblatträndern). Dies reicht aus, um mit bloßem Auge ein schönes Bild mit begrenztem Überschwingen zu erhalten:

Schließlich ist hier der Code, den ich verwendet habe, um die beiden obigen Bilder zu generieren:

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace std;
using namespace cv;

Mat usm(Mat original, float radius, float amount, float threshold)
{
    // work using floating point images to avoid overflows
    cv::Mat input;
    original.convertTo(input, CV_32FC3);

    // copy original for our return value
    Mat retbuf = input.clone();

    // create the blurred copy
    Mat blurred;
    cv::GaussianBlur(input, blurred, cv::Size(0, 0), radius);

    // subtract blurred from original, pixel-by-pixel to make unsharp mask
    Mat unsharpMask;
    cv::subtract(input, blurred, unsharpMask);
    
    // --- filter on the mask ---
    
    //cv::medianBlur(unsharpMask, unsharpMask, 3);
    cv::blur(unsharpMask, unsharpMask, {3,3});
    
    // --- end filter ---

    // apply mask to image
    for (int row = 0; row < original.rows; row++) 
    {
        for (int col = 0; col < original.cols; col++) 
        {
            Vec3f origColor = input.at<Vec3f>(row, col);
            Vec3f difference = unsharpMask.at<Vec3f>(row, col);

            if(cv::norm(difference) >= threshold) {
                retbuf.at<Vec3f>(row, col) = origColor + amount * difference;
            }
        }
    }

    // convert back to unsigned char
    cv::Mat ret;
    retbuf.convertTo(ret, CV_8UC3);

    return ret;
}

int main(int argc, char* argv[])
{
    if (argc < 3) exit(1);
    Mat original = imread(argv[1]);
    Mat expected = imread(argv[2]);
    
    // closer to Photoshop
    Mat current = usm(original, 0.8, 12., 1.);
    
    // better settings (in my opinion)
    //Mat current = usm(original, 2., 1., 3.);
    
    cv::imwrite("current.png", current);
    
    // comparison plot
    cv::Rect crop(127, 505, 163, 120);
    cv::Mat crops[3];
    cv::resize(original(crop), crops[0], {0,0}, 4, 4, cv::INTER_NEAREST);
    cv::resize(expected(crop), crops[1], {0,0}, 4, 4, cv::INTER_NEAREST);
    cv::resize( current(crop), crops[2], {0,0}, 4, 4, cv::INTER_NEAREST);
    
    char const* texts[] = {"original", "photoshop", "current"};
    
    cv::Mat plot = cv::Mat::zeros(120 * 4, 163 * 4 * 3, CV_8UC3);
    for(int i = 0; i < 3; ++i) {
        cv::Rect region(163 * 4 * i, 0, 163 * 4, 120 * 4);
        crops[i].copyTo(plot(region));
        cv::putText(plot, texts[i], region.tl() + cv::Point{5,40}, 
            cv::FONT_HERSHEY_SIMPLEX, 1.5, CV_RGB(255, 0, 0), 2.0);
    }
    
    cv::imwrite("plot.png", plot); 
}

Beantwortet von – vvanpelt

Antwort geprüft von – Mildred Charles (FixError Admin)