image क्या यह पता लगाने का कोई तरीका है कि कोई छवि धुंधली है या नहीं?




image-processing opencv (9)

मैं सोच रहा था कि छवि डेटा का विश्लेषण करके कोई छवि धुंधली है या नहीं, यह निर्धारित करने का कोई तरीका है या नहीं।


एक तरीका जिस पर मैं वर्तमान में छवियों में किनारों के फैलाव का उपयोग कर रहा हूं। इस पेपर की तलाश करें:

@ARTICLE{Marziliano04perceptualblur,
    author = {Pina Marziliano and Frederic Dufaux and Stefan Winkler and Touradj Ebrahimi},
    title = {Perceptual blur and ringing metrics: Application to JPEG2000,” Signal Process},
    journal = {Image Commun},
    year = {2004},
    pages = {163--172} }

यह आमतौर पर पेवेलवॉल के पीछे होता है लेकिन मैंने कुछ मुफ्त प्रतियां देखी हैं। असल में, वे एक छवि में ऊर्ध्वाधर किनारों का पता लगाते हैं, और फिर मापते हैं कि किनारों के किनारे हैं। चौड़ाई औसत औसत छवि के लिए अंतिम धुंध अनुमान परिणाम देता है। व्यापक किनारों धुंधली छवियों के अनुरूप है, और इसके विपरीत।

यह समस्या नो-रेफरेंस छवि गुणवत्ता अनुमान के क्षेत्र से संबंधित है। यदि आप इसे Google विद्वान पर देखते हैं, तो आपको बहुत सारे उपयोगी संदर्भ मिलेंगे।

संपादित करें

निकी के पोस्ट में 5 छवियों के लिए प्राप्त धुंध अनुमानों का एक साजिश यहां दिया गया है। उच्च मूल्य अधिक धुंध से मेल खाते हैं। मैंने एक निश्चित आकार 11x11 गॉसियन फ़िल्टर का उपयोग किया और मानक विचलन (धुंधली छवियों को प्राप्त करने के लिए छविमैजिक के convert कमांड का उपयोग करके) अलग किया।

यदि आप विभिन्न आकारों की छवियों की तुलना करते हैं, तो छवि चौड़ाई से सामान्यीकृत करना न भूलें, क्योंकि बड़ी छवियों में व्यापक किनारे होंगे।

अंत में, एक महत्वपूर्ण समस्या कलात्मक धुंध और अवांछित धुंध (फोकस मिस, संपीड़न, कैमरे के विषय की सापेक्ष गति के कारण) के बीच अंतर कर रही है, लेकिन यह इस तरह के सरल दृष्टिकोण से परे है। कलात्मक धुंध के उदाहरण के लिए, लेनना छवि पर एक नज़र डालें: दर्पण में लेनना का प्रतिबिंब धुंधला है, लेकिन उसका चेहरा पूरी तरह से ध्यान में है। यह लेनना छवि के लिए एक उच्च धुंध अनुमान में योगदान देता है।


नाइकी के जवाब का निर्माण ओपनसीवी के साथ लैपलाइसियन आधारित विधि को लागू करने के लिए यह सीधा है:

short GetSharpness(char* data, unsigned int width, unsigned int height)
{
    // assumes that your image is already in planner yuv or 8 bit greyscale
    IplImage* in = cvCreateImage(cvSize(width,height),IPL_DEPTH_8U,1);
    IplImage* out = cvCreateImage(cvSize(width,height),IPL_DEPTH_16S,1);
    memcpy(in->imageData,data,width*height);

    // aperture size of 1 corresponds to the correct matrix
    cvLaplace(in, out, 1);

    short maxLap = -32767;
    short* imgData = (short*)out->imageData;
    for(int i =0;i<(out->imageSize/2);i++)
    {
        if(imgData[i] > maxLap) maxLap = imgData[i];
    }

    cvReleaseImage(&in);
    cvReleaseImage(&out);
    return maxLap;
}

असली दुनिया के नमूनों पर मेरे परीक्षणों के आधार पर पता चला कि अधिकतम तेजता का संकेत मिलता है, यह एक बहुत अच्छा संकेतक है कि कैमरा एक फोकस में है या नहीं। आश्चर्य की बात नहीं है, सामान्य मूल्य दृश्य निर्भर हैं लेकिन एफएफटी विधि से बहुत कम है जो मेरे आवेदन में उपयोगी होने के लिए झूठी सकारात्मक दर से अधिक है।


एक ऑटो फोकस लेंस के साथ कुछ काम के दौरान, मैं छवि फोकस का पता लगाने के लिए एल्गोरिदम के इस बहुत उपयोगी सेट में आया था। इसे MATLAB में कार्यान्वित किया गया है, लेकिन अधिकांश कार्यों को पोर्ट 2 filter2D साथ filter2D बंदरगाह के लिए काफी आसान है।

यह मूल रूप से कई फोकस मापन एल्गोरिदम का एक सर्वेक्षण कार्यान्वयन है। यदि आप मूल कागजात पढ़ना चाहते हैं, तो एल्गोरिदम के लेखकों के संदर्भ कोड में प्रदान किए जाते हैं। पेर्टज़, एट अल द्वारा 2012 का पेपर। फोकस मापन ऑपरेटरों का विश्लेषण फोकस (एसएफएफ) से आकार के लिए इन सभी उपायों के साथ-साथ उनके प्रदर्शन (दोनों एसएफएफ पर लागू गति और सटीकता के मामले में) की एक अच्छी समीक्षा देता है।

संपादित करें: लिंक मरने के मामले में बस MATLAB कोड जोड़ा गया।

function FM = fmeasure(Image, Measure, ROI)
%This function measures the relative degree of focus of 
%an image. It may be invoked as:
%
%   FM = fmeasure(Image, Method, ROI)
%
%Where 
%   Image,  is a grayscale image and FM is the computed
%           focus value.
%   Method, is the focus measure algorithm as a string.
%           see 'operators.txt' for a list of focus 
%           measure methods. 
%   ROI,    Image ROI as a rectangle [xo yo width heigth].
%           if an empty argument is passed, the whole
%           image is processed.
%
%  Said Pertuz
%  Abr/2010


if ~isempty(ROI)
    Image = imcrop(Image, ROI);
end

WSize = 15; % Size of local window (only some operators)

switch upper(Measure)
    case 'ACMO' % Absolute Central Moment (Shirvaikar2004)
        if ~isinteger(Image), Image = im2uint8(Image);
        end
        FM = AcMomentum(Image);

    case 'BREN' % Brenner's (Santos97)
        [M N] = size(Image);
        DH = Image;
        DV = Image;
        DH(1:M-2,:) = diff(Image,2,1);
        DV(:,1:N-2) = diff(Image,2,2);
        FM = max(DH, DV);        
        FM = FM.^2;
        FM = mean2(FM);

    case 'CONT' % Image contrast (Nanda2001)
        ImContrast = inline('sum(abs(x(:)-x(5)))');
        FM = nlfilter(Image, [3 3], ImContrast);
        FM = mean2(FM);

    case 'CURV' % Image Curvature (Helmli2001)
        if ~isinteger(Image), Image = im2uint8(Image);
        end
        M1 = [-1 0 1;-1 0 1;-1 0 1];
        M2 = [1 0 1;1 0 1;1 0 1];
        P0 = imfilter(Image, M1, 'replicate', 'conv')/6;
        P1 = imfilter(Image, M1', 'replicate', 'conv')/6;
        P2 = 3*imfilter(Image, M2, 'replicate', 'conv')/10 ...
            -imfilter(Image, M2', 'replicate', 'conv')/5;
        P3 = -imfilter(Image, M2, 'replicate', 'conv')/5 ...
            +3*imfilter(Image, M2, 'replicate', 'conv')/10;
        FM = abs(P0) + abs(P1) + abs(P2) + abs(P3);
        FM = mean2(FM);

    case 'DCTE' % DCT energy ratio (Shen2006)
        FM = nlfilter(Image, [8 8], @DctRatio);
        FM = mean2(FM);

    case 'DCTR' % DCT reduced energy ratio (Lee2009)
        FM = nlfilter(Image, [8 8], @ReRatio);
        FM = mean2(FM);

    case 'GDER' % Gaussian derivative (Geusebroek2000)        
        N = floor(WSize/2);
        sig = N/2.5;
        [x,y] = meshgrid(-N:N, -N:N);
        G = exp(-(x.^2+y.^2)/(2*sig^2))/(2*pi*sig);
        Gx = -x.*G/(sig^2);Gx = Gx/sum(Gx(:));
        Gy = -y.*G/(sig^2);Gy = Gy/sum(Gy(:));
        Rx = imfilter(double(Image), Gx, 'conv', 'replicate');
        Ry = imfilter(double(Image), Gy, 'conv', 'replicate');
        FM = Rx.^2+Ry.^2;
        FM = mean2(FM);

    case 'GLVA' % Graylevel variance (Krotkov86)
        FM = std2(Image);

    case 'GLLV' %Graylevel local variance (Pech2000)        
        LVar = stdfilt(Image, ones(WSize,WSize)).^2;
        FM = std2(LVar)^2;

    case 'GLVN' % Normalized GLV (Santos97)
        FM = std2(Image)^2/mean2(Image);

    case 'GRAE' % Energy of gradient (Subbarao92a)
        Ix = Image;
        Iy = Image;
        Iy(1:end-1,:) = diff(Image, 1, 1);
        Ix(:,1:end-1) = diff(Image, 1, 2);
        FM = Ix.^2 + Iy.^2;
        FM = mean2(FM);

    case 'GRAT' % Thresholded gradient (Snatos97)
        Th = 0; %Threshold
        Ix = Image;
        Iy = Image;
        Iy(1:end-1,:) = diff(Image, 1, 1);
        Ix(:,1:end-1) = diff(Image, 1, 2);
        FM = max(abs(Ix), abs(Iy));
        FM(FM<Th)=0;
        FM = sum(FM(:))/sum(sum(FM~=0));

    case 'GRAS' % Squared gradient (Eskicioglu95)
        Ix = diff(Image, 1, 2);
        FM = Ix.^2;
        FM = mean2(FM);

    case 'HELM' %Helmli's mean method (Helmli2001)        
        MEANF = fspecial('average',[WSize WSize]);
        U = imfilter(Image, MEANF, 'replicate');
        R1 = U./Image;
        R1(Image==0)=1;
        index = (U>Image);
        FM = 1./R1;
        FM(index) = R1(index);
        FM = mean2(FM);

    case 'HISE' % Histogram entropy (Krotkov86)
        FM = entropy(Image);

    case 'HISR' % Histogram range (Firestone91)
        FM = max(Image(:))-min(Image(:));


    case 'LAPE' % Energy of laplacian (Subbarao92a)
        LAP = fspecial('laplacian');
        FM = imfilter(Image, LAP, 'replicate', 'conv');
        FM = mean2(FM.^2);

    case 'LAPM' % Modified Laplacian (Nayar89)
        M = [-1 2 -1];        
        Lx = imfilter(Image, M, 'replicate', 'conv');
        Ly = imfilter(Image, M', 'replicate', 'conv');
        FM = abs(Lx) + abs(Ly);
        FM = mean2(FM);

    case 'LAPV' % Variance of laplacian (Pech2000)
        LAP = fspecial('laplacian');
        ILAP = imfilter(Image, LAP, 'replicate', 'conv');
        FM = std2(ILAP)^2;

    case 'LAPD' % Diagonal laplacian (Thelen2009)
        M1 = [-1 2 -1];
        M2 = [0 0 -1;0 2 0;-1 0 0]/sqrt(2);
        M3 = [-1 0 0;0 2 0;0 0 -1]/sqrt(2);
        F1 = imfilter(Image, M1, 'replicate', 'conv');
        F2 = imfilter(Image, M2, 'replicate', 'conv');
        F3 = imfilter(Image, M3, 'replicate', 'conv');
        F4 = imfilter(Image, M1', 'replicate', 'conv');
        FM = abs(F1) + abs(F2) + abs(F3) + abs(F4);
        FM = mean2(FM);

    case 'SFIL' %Steerable filters (Minhas2009)
        % Angles = [0 45 90 135 180 225 270 315];
        N = floor(WSize/2);
        sig = N/2.5;
        [x,y] = meshgrid(-N:N, -N:N);
        G = exp(-(x.^2+y.^2)/(2*sig^2))/(2*pi*sig);
        Gx = -x.*G/(sig^2);Gx = Gx/sum(Gx(:));
        Gy = -y.*G/(sig^2);Gy = Gy/sum(Gy(:));
        R(:,:,1) = imfilter(double(Image), Gx, 'conv', 'replicate');
        R(:,:,2) = imfilter(double(Image), Gy, 'conv', 'replicate');
        R(:,:,3) = cosd(45)*R(:,:,1)+sind(45)*R(:,:,2);
        R(:,:,4) = cosd(135)*R(:,:,1)+sind(135)*R(:,:,2);
        R(:,:,5) = cosd(180)*R(:,:,1)+sind(180)*R(:,:,2);
        R(:,:,6) = cosd(225)*R(:,:,1)+sind(225)*R(:,:,2);
        R(:,:,7) = cosd(270)*R(:,:,1)+sind(270)*R(:,:,2);
        R(:,:,7) = cosd(315)*R(:,:,1)+sind(315)*R(:,:,2);
        FM = max(R,[],3);
        FM = mean2(FM);

    case 'SFRQ' % Spatial frequency (Eskicioglu95)
        Ix = Image;
        Iy = Image;
        Ix(:,1:end-1) = diff(Image, 1, 2);
        Iy(1:end-1,:) = diff(Image, 1, 1);
        FM = mean2(sqrt(double(Iy.^2+Ix.^2)));

    case 'TENG'% Tenengrad (Krotkov86)
        Sx = fspecial('sobel');
        Gx = imfilter(double(Image), Sx, 'replicate', 'conv');
        Gy = imfilter(double(Image), Sx', 'replicate', 'conv');
        FM = Gx.^2 + Gy.^2;
        FM = mean2(FM);

    case 'TENV' % Tenengrad variance (Pech2000)
        Sx = fspecial('sobel');
        Gx = imfilter(double(Image), Sx, 'replicate', 'conv');
        Gy = imfilter(double(Image), Sx', 'replicate', 'conv');
        G = Gx.^2 + Gy.^2;
        FM = std2(G)^2;

    case 'VOLA' % Vollath's correlation (Santos97)
        Image = double(Image);
        I1 = Image; I1(1:end-1,:) = Image(2:end,:);
        I2 = Image; I2(1:end-2,:) = Image(3:end,:);
        Image = Image.*(I1-I2);
        FM = mean2(Image);

    case 'WAVS' %Sum of Wavelet coeffs (Yang2003)
        [C,S] = wavedec2(Image, 1, 'db6');
        H = wrcoef2('h', C, S, 'db6', 1);   
        V = wrcoef2('v', C, S, 'db6', 1);   
        D = wrcoef2('d', C, S, 'db6', 1);   
        FM = abs(H) + abs(V) + abs(D);
        FM = mean2(FM);

    case 'WAVV' %Variance of  Wav...(Yang2003)
        [C,S] = wavedec2(Image, 1, 'db6');
        H = abs(wrcoef2('h', C, S, 'db6', 1));
        V = abs(wrcoef2('v', C, S, 'db6', 1));
        D = abs(wrcoef2('d', C, S, 'db6', 1));
        FM = std2(H)^2+std2(V)+std2(D);

    case 'WAVR'
        [C,S] = wavedec2(Image, 3, 'db6');
        H = abs(wrcoef2('h', C, S, 'db6', 1));   
        V = abs(wrcoef2('v', C, S, 'db6', 1));   
        D = abs(wrcoef2('d', C, S, 'db6', 1)); 
        A1 = abs(wrcoef2('a', C, S, 'db6', 1));
        A2 = abs(wrcoef2('a', C, S, 'db6', 2));
        A3 = abs(wrcoef2('a', C, S, 'db6', 3));
        A = A1 + A2 + A3;
        WH = H.^2 + V.^2 + D.^2;
        WH = mean2(WH);
        WL = mean2(A);
        FM = WH/WL;
    otherwise
        error('Unknown measure %s',upper(Measure))
end
 end
%************************************************************************
function fm = AcMomentum(Image)
[M N] = size(Image);
Hist = imhist(Image)/(M*N);
Hist = abs((0:255)-255*mean2(Image))'.*Hist;
fm = sum(Hist);
end

%******************************************************************
function fm = DctRatio(M)
MT = dct2(M).^2;
fm = (sum(MT(:))-MT(1,1))/MT(1,1);
end

%************************************************************************
function fm = ReRatio(M)
M = dct2(M);
fm = (M(1,2)^2+M(1,3)^2+M(2,1)^2+M(2,2)^2+M(3,1)^2)/(M(1,1)^2);
end
%******************************************************************

ओपनसीवी संस्करणों के कुछ उदाहरण:

// OpenCV port of 'LAPM' algorithm (Nayar89)
double modifiedLaplacian(const cv::Mat& src)
{
    cv::Mat M = (Mat_<double>(3, 1) << -1, 2, -1);
    cv::Mat G = cv::getGaussianKernel(3, -1, CV_64F);

    cv::Mat Lx;
    cv::sepFilter2D(src, Lx, CV_64F, M, G);

    cv::Mat Ly;
    cv::sepFilter2D(src, Ly, CV_64F, G, M);

    cv::Mat FM = cv::abs(Lx) + cv::abs(Ly);

    double focusMeasure = cv::mean(FM).val[0];
    return focusMeasure;
}

// OpenCV port of 'LAPV' algorithm (Pech2000)
double varianceOfLaplacian(const cv::Mat& src)
{
    cv::Mat lap;
    cv::Laplacian(src, lap, CV_64F);

    cv::Scalar mu, sigma;
    cv::meanStdDev(lap, mu, sigma);

    double focusMeasure = sigma.val[0]*sigma.val[0];
    return focusMeasure;
}

// OpenCV port of 'TENG' algorithm (Krotkov86)
double tenengrad(const cv::Mat& src, int ksize)
{
    cv::Mat Gx, Gy;
    cv::Sobel(src, Gx, CV_64F, 1, 0, ksize);
    cv::Sobel(src, Gy, CV_64F, 0, 1, ksize);

    cv::Mat FM = Gx.mul(Gx) + Gy.mul(Gy);

    double focusMeasure = cv::mean(FM).val[0];
    return focusMeasure;
}

// OpenCV port of 'GLVN' algorithm (Santos97)
double normalizedGraylevelVariance(const cv::Mat& src)
{
    cv::Scalar mu, sigma;
    cv::meanStdDev(src, mu, sigma);

    double focusMeasure = (sigma.val[0]*sigma.val[0]) / mu.val[0];
    return focusMeasure;
}

इन उपायों से आपकी आवश्यकताओं के लिए सबसे अच्छा विकल्प है या नहीं, इस पर कोई गारंटी नहीं है, लेकिन यदि आप इन उपायों से जुड़े कागजात को ट्रैक करते हैं, तो वे आपको अधिक अंतर्दृष्टि दे सकते हैं। आशा है कि आपको कोड उपयोगी लगेगा! मुझे पता है मैंने किया था।


मैं एक पूरी तरह से अलग समाधान के साथ आया था। मुझे हर (एक्स) फ्रेम में सबसे तेज एक खोजने के लिए वीडियो अभी भी फ्रेम का विश्लेषण करने की आवश्यकता है। इस तरह, मैं फोकस छवियों के गति धुंध और / या बाहर पता लगाएगा।

मैं कैनी एज पहचान का उपयोग कर समाप्त हुआ और मुझे लगभग हर तरह के वीडियो के साथ बहुत अच्छे परिणाम मिल गए (निकी की विधि के साथ, मुझे डिजिटल वीएचएस वीडियो और भारी इंटरलस्ड वीडियो के साथ समस्याएं थीं)।

मैंने मूल छवि पर रुचि के क्षेत्र (आरओआई) को सेट करके प्रदर्शन को अनुकूलित किया।

EmguCV का उपयोग करना:

//Convert image using Canny
using (Image<Gray, byte> imgCanny = imgOrig.Canny(225, 175))
{
    //Count the number of pixel representing an edge
    int nCountCanny = imgCanny.CountNonzero()[0];

    //Compute a sharpness grade:
    //< 1.5 = blurred, in movement
    //de 1.5 à 6 = acceptable
    //> 6 =stable, sharp
    double dSharpness = (nCountCanny * 1000.0 / (imgCanny.Cols * imgCanny.Rows));
}

किसी छवि की तीखेपन का अनुमान लगाने का एक और आसान तरीका लैपलेस (या लोग) फ़िल्टर का उपयोग करना है और बस अधिकतम मान चुनें। 99.9% क्वांटाइल जैसे मजबूत उपाय का उपयोग करना शायद बेहतर होता है यदि आप शोर की अपेक्षा करते हैं (यानी उच्चतम विपरीत के बजाय एनएचटी-उच्चतम कंट्रास्ट चुनना।) यदि आप अलग-अलग छवि चमक की अपेक्षा करते हैं, तो आपको छवि चमक / सामान्य करने के लिए प्रीप्रोसेसिंग चरण भी शामिल करना चाहिए। इसके विपरीत (उदाहरण के लिए हिस्टोग्राम बराबरता)।

मैंने साइमन के सुझाव को लागू किया है और यह गणित में है, और इसे कुछ परीक्षण छवियों पर आजमाया है:

पहला परीक्षण एक अलग कर्नेल आकार के साथ गॉसियन फ़िल्टर का उपयोग करके परीक्षण छवियों को धुंधला करता है, फिर धुंधली छवि के एफएफटी की गणना करता है और 90% उच्चतम आवृत्तियों का औसत लेता है:

testFft[img_] := Table[
  (
   blurred = GaussianFilter[img, r];
   fft = Fourier[ImageData[blurred]];
   {w, h} = Dimensions[fft];
   windowSize = Round[w/2.1];
   Mean[Flatten[(Abs[
       fft[[w/2 - windowSize ;; w/2 + windowSize, 
         h/2 - windowSize ;; h/2 + windowSize]]])]]
   ), {r, 0, 10, 0.5}]

एक लॉगरिदमिक साजिश में परिणाम:

5 लाइनें 5 परीक्षण छवियों का प्रतिनिधित्व करती हैं, एक्स अक्ष गॉसियन फ़िल्टर त्रिज्या का प्रतिनिधित्व करती है। ग्राफ कम हो रहे हैं, इसलिए एफएफटी तेजता के लिए एक अच्छा उपाय है।

यह "उच्चतम LoG" धुंधला अनुमानक के लिए कोड है: यह केवल एक LoG फ़िल्टर लागू करता है और फ़िल्टर परिणाम में सबसे चमकदार पिक्सेल देता है:

testLaplacian[img_] := Table[
  (
   blurred = GaussianFilter[img, r];
   Max[Flatten[ImageData[LaplacianGaussianFilter[blurred, 1]]]];
   ), {r, 0, 10, 0.5}]

एक लॉगरिदमिक साजिश में परिणाम:

अन-धुंधली छवियों के लिए प्रसार थोड़ा बेहतर है (2.5 बनाम 3.3), मुख्य रूप से क्योंकि यह विधि केवल छवि में सबसे मजबूत विपरीतता का उपयोग करती है, जबकि एफएफटी अनिवार्य रूप से पूरी छवि पर एक माध्यम है। फ़ंक्शंस भी तेजी से घट रहे हैं, इसलिए "धुंधला" थ्रेसहोल्ड सेट करना आसान हो सकता है।


उस महान लैपलेस सुझाव के लिए धन्यवाद nikie। ओपनसीवी दस्तावेज़ों ने मुझे एक ही दिशा में इंगित किया: पायथन, सीवी 2 (ओपनसीवी 2.4.10), और numpy का उपयोग कर ...

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) numpy.max(cv2.convertScaleAbs(cv2.Laplacian(gray_image,3)))

परिणाम 0-255 के बीच है। मैंने पाया कि 200 से अधिक कुछ भी ध्यान में है, और 100 तक, यह काफी हद तक धुंधला है। अधिकतम पूरी तरह से धुंधला होने पर भी अधिकतम 20 के तहत वास्तव में कभी नहीं मिलता है।


अत्यधिक सम्मानित पत्रिकाओं (छवि प्रसंस्करण पर आईईईई लेनदेन) में प्रकाशित दो विधियों के मैटलैब कोड यहां उपलब्ध हैं: https://ivulab.asu.edu/software

सीपीबीडीएम और जेएनबीएम एल्गोरिदम की जांच करें। यदि आप कोड की जांच करते हैं तो इसे पोर्ट करना बहुत मुश्किल नहीं है और आकस्मिक रूप से यह मार्ज़ियालियानो की विधि को मूलभूत सुविधा के आधार पर आधारित है।


मैंने this पोस्ट से लैपलासीन फ़िल्टर के आधार पर समाधान की कोशिश की। यह मेरी मदद नहीं करता था। इसलिए, मैंने this पोस्ट से समाधान की कोशिश की और यह मेरे मामले के लिए अच्छा था (लेकिन धीमा है):

import cv2

image = cv2.imread("test.jpeg")
height, width = image.shape[:2]
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

def px(x, y):
    return int(gray[y, x])

sum = 0
for x in range(width-1):
    for y in range(height):
        sum += abs(px(x, y) - px(x+1, y))

कम धुंधली छवि का अधिकतम sum मूल्य है!

आप चरण बदलकर गति और सटीकता को भी ट्यून कर सकते हैं, उदाहरण के लिए

यह भाग

for x in range(width - 1):

आप इसके साथ प्रतिस्थापित कर सकते हैं

for x in range(0, width - 1, 10):

उत्तर से कई जवाब स्पष्ट हैं, लेकिन मुझे लगता है कि यह एक वैचारिक भेद बनाने के लिए उपयोगी है।

क्या होगा यदि आप एक धुंधली छवि की पूरी तरह से फोकस तस्वीर लेते हैं?

जब आपके पास संदर्भ होता है तो अस्पष्ट पहचान समस्या केवल अच्छी तरह से उत्पन्न होती है। यदि आपको डिज़ाइन करने की आवश्यकता है, उदाहरण के लिए, एक ऑटो-फ़ोकस सिस्टम, आप धुंधली या चिकनाई की विभिन्न डिग्री के साथ ली गई छवियों के अनुक्रम की तुलना करते हैं, और आप इस सेट के भीतर न्यूनतम धुंधला करने का बिंदु ढूंढने का प्रयास करते हैं। मैं अन्य शब्दों को ऊपर वर्णित तकनीकों में से एक का उपयोग करके विभिन्न छवियों को संदर्भित करने की आवश्यकता है (मूल रूप से - दृष्टिकोण में परिष्करण के विभिन्न संभावित स्तरों के साथ - उच्चतम आवृत्ति सामग्री वाले एक छवि की तलाश में)।







opencv