OpenCV C ++ / Obj-C: Erkennen eines Blattes Papier / Quadraterkennung

Ich habe das OpenCV-Quadraterkennungsbeispiel erfolgreich in meiner Testanwendung implementiert, muss jetzt aber die Ausgabe filtern, da sie ziemlich chaotisch ist - oder ist mein Code falsch?

Ich bin für Skew Reduktion in den vier Eckpunkten des Papiers interessiert (wie das ) und die weitere Verarbeitung ...

Input-Output:

Original Bild:

klicken

Code:

double angle( cv::Point pt1, cv::Point pt2, cv::Point pt0 ) {
    double dx1 = pt1.x - pt0.x;
    double dy1 = pt1.y - pt0.y;
    double dx2 = pt2.x - pt0.x;
    double dy2 = pt2.y - pt0.y;
    return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10);
}

- (std::vector<std::vector<cv::Point> >)findSquaresInImage:(cv::Mat)_image
{
    std::vector<std::vector<cv::Point> > squares;
    cv::Mat pyr, timg, gray0(_image.size(), CV_8U), gray;
    int thresh = 50, N = 11;
    cv::pyrDown(_image, pyr, cv::Size(_image.cols/2, _image.rows/2));
    cv::pyrUp(pyr, timg, _image.size());
    std::vector<std::vector<cv::Point> > contours;
    for( int c = 0; c < 3; c++ ) {
        int ch[] = {c, 0};
        mixChannels(&timg, 1, &gray0, 1, ch, 1);
        for( int l = 0; l < N; l++ ) {
            if( l == 0 ) {
                cv::Canny(gray0, gray, 0, thresh, 5);
                cv::dilate(gray, gray, cv::Mat(), cv::Point(-1,-1));
            }
            else {
                gray = gray0 >= (l+1)*255/N;
            }
            cv::findContours(gray, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);
            std::vector<cv::Point> approx;
            for( size_t i = 0; i < contours.size(); i++ )
            {
                cv::approxPolyDP(cv::Mat(contours[i]), approx, arcLength(cv::Mat(contours[i]), true)*0.02, true);
                if( approx.size() == 4 && fabs(contourArea(cv::Mat(approx))) > 1000 && cv::isContourConvex(cv::Mat(approx))) {
                    double maxCosine = 0;

                    for( int j = 2; j < 5; j++ )
                    {
                        double cosine = fabs(angle(approx[j%4], approx[j-2], approx[j-1]));
                        maxCosine = MAX(maxCosine, cosine);
                    }

                    if( maxCosine < 0.3 ) {
                        squares.push_back(approx);
                    }
                }
            }
        }
    }
    return squares;
}

EDIT 17/08/2012:

Verwenden Sie diesen Code, um die erkannten Quadrate auf dem Bild zu zeichnen:

cv::Mat debugSquares( std::vector<std::vector<cv::Point> > squares, cv::Mat image )
{
    for ( int i = 0; i< squares.size(); i++ ) {
        // draw contour
        cv::drawContours(image, squares, i, cv::Scalar(255,0,0), 1, 8, std::vector<cv::Vec4i>(), 0, cv::Point());

        // draw bounding rect
        cv::Rect rect = boundingRect(cv::Mat(squares[i]));
        cv::rectangle(image, rect.tl(), rect.br(), cv::Scalar(0,255,0), 2, 8, 0);

        // draw rotated rect
        cv::RotatedRect minRect = minAreaRect(cv::Mat(squares[i]));
        cv::Point2f rect_points[4];
        minRect.points( rect_points );
        for ( int j = 0; j < 4; j++ ) {
            cv::line( image, rect_points[j], rect_points[(j+1)%4], cv::Scalar(0,0,255), 1, 8 ); // blue
        }
    }

    return image;
}

Dies ist ein wiederkehrendes Thema in Stackoverflow. Da ich keine relevante Implementierung finden konnte, habe ich mich entschlossen, die Herausforderung anzunehmen.

Ich habe einige Änderungen an der in OpenCV vorhandenen Squares-Demo vorgenommen, und der resultierende C ++ - Code unten kann ein Blatt Papier im Bild erkennen:

void find_squares(Mat& image, vector<vector<Point> >& squares)
{
    // blur will enhance edge detection
    Mat blurred(image);
    medianBlur(image, blurred, 9);

    Mat gray0(blurred.size(), CV_8U), gray;
    vector<vector<Point> > contours;

    // find squares in every color plane of the image
    for (int c = 0; c < 3; c++)
    {
        int ch[] = {c, 0};
        mixChannels(&blurred, 1, &gray0, 1, ch, 1);

        // try several threshold levels
        const int threshold_level = 2;
        for (int l = 0; l < threshold_level; l++)
        {
            // Use Canny instead of zero threshold level!
            // Canny helps to catch squares with gradient shading
            if (l == 0)
            {
                Canny(gray0, gray, 10, 20, 3); // 

                // Dilate helps to remove potential holes between edge segments
                dilate(gray, gray, Mat(), Point(-1,-1));
            }
            else
            {
                    gray = gray0 >= (l+1) * 255 / threshold_level;
            }

            // Find contours and store them in a list
            findContours(gray, contours, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);

            // Test contours
            vector<Point> approx;
            for (size_t i = 0; i < contours.size(); i++)
            {
                    // approximate contour with accuracy proportional
                    // to the contour perimeter
                    approxPolyDP(Mat(contours[i]), approx, arcLength(Mat(contours[i]), true)*0.02, true);

                    // Note: absolute value of an area is used because
                    // area may be positive or negative - in accordance with the
                    // contour orientation
                    if (approx.size() == 4 &&
                            fabs(contourArea(Mat(approx))) > 1000 &&
                            isContourConvex(Mat(approx)))
                    {
                            double maxCosine = 0;

                            for (int j = 2; j < 5; j++)
                            {
                                    double cosine = fabs(angle(approx[j%4], approx[j-2], approx[j-1]));
                                    maxCosine = MAX(maxCosine, cosine);
                            }

                            if (maxCosine < 0.3)
                                    squares.push_back(approx);
                    }
            }
        }
    }
}

Nachdem dieser Vorgang ausgeführt wurde, ist das Blatt Papier das größte Quadrat in vector<vector<Point> >:

Ich lasse Sie die Funktion schreiben, um das größte Quadrat zu finden. ;)

Sofern keine andere Anforderung nicht angegeben ist, würde ich Ihr Farbbild einfach in Graustufen konvertieren und nur damit arbeiten (keine Notwendigkeit, auf den 3 Kanälen zu arbeiten, der vorhandene Kontrast ist bereits zu hoch). Außerdem würde ich mit einer verkleinerten Version Ihrer Bilder arbeiten, es sei denn, es gibt ein spezifisches Problem bei der Größenänderung, da diese relativ groß sind und die Größe dem zu lösenden Problem nichts hinzufügt. Schließlich wird Ihr Problem mit einem Medianfilter, einigen grundlegenden morphologischen Werkzeugen und Statistiken gelöst (hauptsächlich für die Otsu-Schwellwertbildung, die bereits für Sie durchgeführt wurde).

Folgendes erhalte ich mit Ihrem Beispielbild und einem anderen Bild mit einem Blatt Papier, das ich gefunden habe:

Der Medianfilter wird verwendet, um kleinere Details aus dem jetzt Graustufenbild zu entfernen. Möglicherweise werden dünne Linien im weißlichen Papier entfernt, was gut ist, da Sie dann mit winzigen verbundenen Komponenten enden, die leicht zu verwerfen sind. Wenden Sie nach dem Median einen morphologischen Gradienten an (einfach dilation- erosion) und binarisieren Sie das Ergebnis mit Otsu. Der morphologische Gradient ist eine gute Methode, um starke Kanten zu erhalten. Er sollte häufiger verwendet werden. Wenden Sie dann eine morphologische Ausdünnung an, da dieser Gradient die Konturbreite erhöht. Jetzt können Sie kleine Komponenten verwerfen.

An dieser Stelle haben wir Folgendes mit dem rechten Bild oben (vor dem Zeichnen des blauen Polygons), das linke wird nicht angezeigt, da die einzige verbleibende Komponente diejenige ist, die das Papier beschreibt:

In Anbetracht der Beispiele bleibt nur noch die Unterscheidung zwischen Komponenten, die wie Rechtecke aussehen, und anderen, die dies nicht tun. Hierbei wird ein Verhältnis zwischen der Fläche der konvexen Hülle, die die Form enthält, und der Fläche ihres Begrenzungsrahmens bestimmt. Das Verhältnis 0,7 funktioniert für diese Beispiele gut. Es kann vorkommen, dass Sie auch Komponenten im Papier verwerfen müssen, jedoch nicht in diesen Beispielen, indem Sie diese Methode verwenden (dieser Schritt sollte jedoch sehr einfach sein, insbesondere weil er direkt über OpenCV ausgeführt werden kann).

Als Referenz finden Sie hier einen Beispielcode in Mathematica:

f = Import["http://thwartedglamour.files.wordpress.com/2010/06/my-coffee-table-1-sa.jpg"]
f = ImageResize[f, ImageDimensions[f][[1]]/4]
g = MedianFilter[ColorConvert[f, "Grayscale"], 2]
h = DeleteSmallComponents[Thinning[
     Binarize[ImageSubtract[Dilation[g, 1], Erosion[g, 1]]]]]
convexvert = ComponentMeasurements[SelectComponents[
     h, {"ConvexArea", "BoundingBoxArea"}, #1 / #2 > 0.7 &], 
     "ConvexVertices"][[All, 2]]
(* To visualize the blue polygons above: *)
Show[f, Graphics[{EdgeForm[{Blue, Thick}], RGBColor[0, 0, 1, 0.5], 
     Polygon @@ convexvert}]]

Wenn es unterschiedlichere Situationen gibt, in denen das Rechteck des Papiers nicht so gut definiert ist oder der Ansatz es mit anderen Formen verwechselt - diese Situationen können aus verschiedenen Gründen auftreten, aber eine häufige Ursache ist eine schlechte Bildaufnahme -, versuchen Sie, das Pre zu kombinieren -Verarbeitungsschritte mit der im Artikel "Rechteckerkennung basierend auf einer Windowed Hough Transformation" beschriebenen Arbeit.

Nun, ich bin zu spät.

In Ihrem Bild ist das Papier white, während der Hintergrund ist colored. Es ist also besser zu erkennen, dass das Papier Saturation(饱和度)kanalisiert ist HSV color space. Lesen Sie zuerst das Wiki HSL_and_HSV . Dann kopiere ich die meisten Ideen aus meiner Antwort in dieses farbige Segment erkennen in ein Bild .

Hauptschritte:

1. Lesen Sie in BGR
2. Konvertieren Sie das Bild von bgrin den hsvWeltraum
3. Schwelle zum S-Kanal
4. Finden Sie dann die maximale Außenkontur (oder tun Sie Cannyoder HoughLineswie Sie möchten, ich wähle findContours), ca., um die Ecken zu erhalten.

Das ist mein Ergebnis:

Der Python-Code (Python 3.5 + OpenCV 3.3):

#!/usr/bin/python3
# 2017.12.20 10:47:28 CST
# 2017.12.20 11:29:30 CST

import cv2
import numpy as np

##(1) read into  bgr-space
img = cv2.imread("test2.jpg")

##(2) convert to hsv-space, then split the channels
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
h,s,v = cv2.split(hsv)

##(3) threshold the S channel using adaptive method(`THRESH_OTSU`) or fixed thresh
th, threshed = cv2.threshold(s, 50, 255, cv2.THRESH_BINARY_INV)

##(4) find all the external contours on the threshed S
#_, cnts, _ = cv2.findContours(threshed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cnts = cv2.findContours(threshed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]

canvas  = img.copy()
#cv2.drawContours(canvas, cnts, -1, (0,255,0), 1)

## sort and choose the largest contour
cnts = sorted(cnts, key = cv2.contourArea)
cnt = cnts[-1]

## approx the contour, so the get the corner points
arclen = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.02* arclen, True)
cv2.drawContours(canvas, [cnt], -1, (255,0,0), 1, cv2.LINE_AA)
cv2.drawContours(canvas, [approx], -1, (0, 0, 255), 1, cv2.LINE_AA)

## Ok, you can see the result as tag(6)
cv2.imwrite("detected.png", canvas)

Verwandte Antworten:

1. Wie erkenne ich mit OpenCV farbige Flecken in einem Bild?
2. Kantenerkennung auf farbigem Hintergrund mit OpenCV
3. OpenCV C ++ / Obj-C: Erkennen eines Blattes Papier / Quadraterkennung
4. Wie verwende ich "cv2.findContours" in verschiedenen OpenCV-Versionen?

Was Sie brauchen, ist ein Viereck anstelle eines gedrehten Rechtecks. RotatedRectgibt Ihnen falsche Ergebnisse. Außerdem benötigen Sie eine perspektivische Projektion.

Grundsätzlich muss Folgendes getan werden:

• Durchlaufen Sie alle Polygonsegmente und verbinden Sie diejenigen, die fast gleich sind.
• Sortieren Sie sie so, dass Sie die 4 größten Liniensegmente haben.
• Schneiden Sie diese Linien und Sie haben die 4 wahrscheinlichsten Eckpunkte.
• Transformieren Sie die Matrix über die aus den Eckpunkten und dem Seitenverhältnis des bekannten Objekts gesammelte Perspektive.

Ich habe eine Klasse implementiert, Quadrangledie sich um die Konvertierung von Konturen in Vierecke kümmert und diese auch über die richtige Perspektive transformiert.

Eine funktionierende Implementierung finden Sie hier: Java OpenCV entwirft eine Kontur

Sobald Sie den Begrenzungsrahmen des Dokuments erkannt haben, können Sie eine Vierpunkt-Perspektiventransformation durchführen , um eine Draufsicht auf das Bild von oben nach unten zu erhalten. Dadurch wird der Versatz behoben und nur das gewünschte Objekt isoliert.

Eingabebild:

Erkanntes Textobjekt

Ansicht des Textdokuments von oben nach unten

Code

from imutils.perspective import four_point_transform
import cv2
import numpy

# Load image, grayscale, Gaussian blur, Otsu's threshold
image = cv2.imread("1.png")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (7,7), 0)
thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]

# Find contours and sort for largest contour
cnts = cv2.findContours(thresh, cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
cnts = cnts[0] if len(cnts) == 2 else cnts[1]
cnts = sorted(cnts, key=cv2.contourArea, reverse=True)
displayCnt = None

for c in cnts:
    # Perform contour approximation
    peri = cv2.arcLength(c, True)
    approx = cv2.approxPolyDP(c, 0.02 * peri, True)
    if len(approx) == 4:
        displayCnt = approx
        break

# Obtain birds' eye view of image
warped = four_point_transform(image, displayCnt.reshape(4, 2))

cv2.imshow("thresh", thresh)
cv2.imshow("warped", warped)
cv2.imshow("image", image)
cv2.waitKey()

Das Erkennen eines Blattes Papier ist eine alte Schule. Wenn Sie sich mit der Erkennung von Schräglauf befassen möchten, ist es besser, wenn Sie sofort die Erkennung von Textzeilen anstreben. Damit erhalten Sie die Extrema links, rechts, oben und unten. Verwerfen Sie alle Grafiken im Bild, wenn Sie dies nicht möchten, und führen Sie dann einige Statistiken zu den Textzeilensegmenten durch, um den am häufigsten auftretenden Winkelbereich bzw. Winkel zu ermitteln. Auf diese Weise werden Sie auf einen guten Schräglaufwinkel eingrenzen. Danach setzen Sie diese Parameter auf den Schräglaufwinkel und die Extreme, um das Bild zu entschneiden und auf das zu schneiden, was erforderlich ist.

Für die aktuelle Bildanforderung ist es besser, CV_RETR_EXTERNAL anstelle von CV_RETR_LIST zu verwenden.

Eine andere Methode zum Erkennen von Kanten besteht darin, einen zufälligen Waldklassifizierer an den Papierkanten zu trainieren und dann den Klassifizierer zu verwenden, um die Kantenzuordnung zu erhalten. Dies ist bei weitem eine robuste Methode, erfordert jedoch Schulung und Zeit.

Zufällige Wälder funktionieren mit Szenarien mit geringem Kontrastunterschied, z. B. Whitepaper auf ungefähr weißem Hintergrund.