MinAreaRect-Winkel - Ungewiss über den zurückgegebenen Winkel

Ich nehme an, du bist mit C++, aber die Antwort sollten die gleichen sein, wenn Sie mit C oder Python.

Die Funktion minAreaRect zu geben scheint Winkel zwischen -90 bis 0 Grad, nicht einschließlich der null, also ein Intervall [-90, 0).

Die Funktion gibt -90 Grad, wenn das Rechteck gibt es nicht gedreht, d.h. das Rechteck hat zwei Seiten genau waagerecht und auf beiden Seiten genau senkrecht. Wie das Rechteck im Uhrzeigersinn dreht, wird der Winkel größer wird (geht gegen null). Wenn null erreicht ist, ist der Winkel gegeben durch die Funktion Zecken wieder auf -90 Grad wieder.

Also, wenn Sie ein langes Rechteck aus minAreaRectund es liegen flach minAreaRect rufen Sie den Winkel -90 Grad. Wenn Sie das Bild drehen, bis das Rechteck gegeben durch minAreaRect ist perfekt aufrecht, dann der Winkel wird sagen -90 Grad wieder.

Ich wollte eigentlich nicht wissen, jede dieser, (ich zögerten aus meiner OpenCV-Projekt, um herauszufinden, wie es funktioniert :/). Wie auch immer, hier ist ein OpenCV Programm, das zeigt minAreaRect wenn ich nicht erklärt es klar genug bereits:

#include <stdio.h>

#include <opencv\cv.h>
#include <opencv\highgui.h>

using namespace cv;

int main() {
    float angle = 0;
    Mat image(200, 400, CV_8UC3, Scalar(0));
    RotatedRect originalRect;
    Point2f vertices[4];
    vector<Point2f> vertVect;
    RotatedRect calculatedRect;

    while (waitKey(5000) != 27) {
        //Create a rectangle, rotating it by 10 degrees more each time.
        originalRect = RotatedRect(Point2f(100,100), Size2f(100,50), angle);

        //Convert the rectangle to a vector of points for minAreaRect to use.
        //Also move the points to the right, so that the two rectangles aren't
        //in the same place.
        originalRect.points(vertices);
        for (int i = 0; i < 4; i++) {
            vertVect.push_back(vertices[i] + Point2f(200, 0));
        }

        //Get minAreaRect to find a rectangle that encloses the points. This
        //should have the exact same orientation as our original rectangle.
        calculatedRect = minAreaRect(vertVect);

        //Draw the original rectangle, and the one given by minAreaRect.
        for (int i = 0; i < 4; i++) {
            line(image, vertices[i], vertices[(i+1)%4], Scalar(0, 255, 0));
            line(image, vertVect[i], vertVect[(i+1)%4], Scalar(255, 0, 0));
        }
        imshow("rectangles", image);

        //Print the angle values.
        printf("---\n");
        printf("Original angle:             %7.2f\n", angle);
        printf("Angle given by minAreaRect: %7.2f\n", calculatedRect.angle);
        printf("---\n");

        //Reset everything for the next frame.
        image = Mat(200, 400, CV_8UC3, Scalar(0));
        vertVect.clear();
        angle+=10;
    }

    return 0;
}

Dadurch können Sie problemlos sehen, wie sich der Winkel und die Form, eine manuell gezeichnete Rechteck im Vergleich zu den minAreaRect interpretation des gleichen Rechtecks.

InformationsquelleAutor der Antwort Adam Goodwin

Nach experiment, finde ich, dass, wenn die long-Seite ist in der linken unteren Punkt, der Wert für den Winkel zwischen der langen Seite und der Y+ Achse, aber wenn die lange Seite ist in der rechten unteren Punkt, der Wert für den Winkel zwischen der langen Seite und X+ - Achse.
Also ich benutze den code wie folgt(java):

       rRect = Imgproc.minAreaRect(mop2f);
       if(rRect.size.width<rRect.size.height){
            angle = 90 -rRect.angle;
        }else{
            angle = -rRect.angle;
        }

Wird der Winkel von 0 bis 180.

InformationsquelleAutor der Antwort silentteen