Exécution de cv:: wopperspective pour un faux deskewing sur un ensemble de cv:: Point

le problème était l'ordre dans lequel les points étaient déclarés à l'intérieur du vecteur, et il y avait aussi une autre question liée à cela sur la définition de dst_vertices .

L'ordre des points de la matière à getPerspectiveTransform() et doivent être spécifiés dans l'ordre suivant:

1st-------2nd
 |         |
 |         |
 |         |
3rd-------4th

par conséquent, les points d'origine devaient être réordonnés à ceci:

vector<Point> not_a_rect_shape;
not_a_rect_shape.push_back(Point(408, 69));
not_a_rect_shape.push_back(Point(1912, 291));
not_a_rect_shape.push_back(Point(72, 2186));
not_a_rect_shape.push_back(Point(1584, 2426));

et le destination:

Point2f dst_vertices[4];
dst_vertices[0] = Point(0, 0);
dst_vertices[1] = Point(box.boundingRect().width-1, 0); // Bug was: had mistakenly switched these 2 parameters
dst_vertices[2] = Point(0, box.boundingRect().height-1);
dst_vertices[3] = Point(box.boundingRect().width-1, box.boundingRect().height-1);

après cela, il faut faire un peu de culture parce que l'image résultante n'est pas seulement la zone à l'intérieur du rectangle vert comme je le pensais:

Je ne sais pas s'il s'agit d'un bug D'OpenCV ou si je manque quelque chose, mais le problème principal a été résolu.

en travaillant avec un quadrangle, OpenCV n'est pas vraiment votre ami. RotatedRect vous donnera des résultats incorrects. Vous aurez également besoin d'une projection en perspective au lieu d'une projection affine comme d'autres mentionnés ici..

d'Abord ce qui doit être fait est la suivante:

• boucle à travers tous les segments de polygones et connecter ceux qui sont presque équel.
• Classez - les de sorte que vous avez les 4 plus grands segments de ligne.
• croisent ces lignes et vous avez les 4 points d'angle les plus probables.
• transformer la matrice sur la perspective recueillie des points d'angle et le rapport d'aspect de l'objet connu.

j'ai mis en œuvre une classe Quadrangle qui prend soin de la conversion contour to quadrangle et qui la transformera également au-dessus de la bonne perspective.

voir la mise en œuvre ici: Java OpenCV correction d'un contour

MISE À JOUR: RÉSOLU

j'ai presque réussi. Si près d'être utilisable. Il désapprouve correctement mais je semble avoir une échelle ou traduire problème. J'ai mis le point d'ancrage à zéro et expérimente aussi de changer le mode d'échelle (aspectFill, ajuster à la page, etc...).

configurer les points de deskew (rouge les rend difficiles à voir):

Appliquer la transformation calculée:

maintenant il désapprouve. Cela semble assez bon, sauf que ses pas centré sur l'écran. En ajoutant un geste de pan à la vue d'image je peux le faire glisser et vérifier qu'il s'aligne:

ce n'est pas aussi simple que traduire par -0.5, -0.5 parce que l'image originale devient un polygone qui s'étire très très loin (potentiellement), donc il est bordant rect est beaucoup plus grand que le cadre de l'écran.

est-ce que quelqu'un voir ce que je peux faire pour obtenir cette enveloppé? J'aimerais avoir commis et de le partager ici. C'est un sujet populaire, mais je n'ai pas trouvé de solution aussi simple que copier/coller.

le code source complet est ici:

clone git https://github.com/zakkhoyt/Quadrilateral.git

git checkout démo

Cependant, je vais coller les parties pertinentes ici. Cette première méthode est à moi et est où Je reçois le redressement des points.

- (IBAction)buttonAction:(id)sender {

    Quadrilateral quadFrom;
    float scale = 1.0;
    quadFrom.topLeft.x = self.topLeftView.center.x / scale;
    quadFrom.topLeft.y = self.topLeftView.center.y / scale;
    quadFrom.topRight.x = self.topRightView.center.x / scale;
    quadFrom.topRight.y = self.topRightView.center.y / scale;
    quadFrom.bottomLeft.x = self.bottomLeftView.center.x / scale;
    quadFrom.bottomLeft.y = self.bottomLeftView.center.y / scale;
    quadFrom.bottomRight.x = self.bottomRightView.center.x / scale;
    quadFrom.bottomRight.y = self.bottomRightView.center.y / scale;

    Quadrilateral quadTo;
    quadTo.topLeft.x = self.view.bounds.origin.x;
    quadTo.topLeft.y = self.view.bounds.origin.y;
    quadTo.topRight.x = self.view.bounds.origin.x + self.view.bounds.size.width;
    quadTo.topRight.y = self.view.bounds.origin.y;
    quadTo.bottomLeft.x = self.view.bounds.origin.x;
    quadTo.bottomLeft.y = self.view.bounds.origin.y + self.view.bounds.size.height;
    quadTo.bottomRight.x = self.view.bounds.origin.x + self.view.bounds.size.width;
    quadTo.bottomRight.y = self.view.bounds.origin.y + self.view.bounds.size.height;

    CATransform3D t = [self transformQuadrilateral:quadFrom toQuadrilateral:quadTo];
//    t = CATransform3DScale(t, 0.5, 0.5, 1.0);
    self.imageView.layer.anchorPoint = CGPointZero;
    [UIView animateWithDuration:1.0 animations:^{
        self.imageView.layer.transform = t;
    }];

}


#pragma mark OpenCV stuff...
-(CATransform3D)transformQuadrilateral:(Quadrilateral)origin toQuadrilateral:(Quadrilateral)destination {

    CvPoint2D32f *cvsrc = [self openCVMatrixWithQuadrilateral:origin];
    CvMat *src_mat = cvCreateMat( 4, 2, CV_32FC1 );
    cvSetData(src_mat, cvsrc, sizeof(CvPoint2D32f));


    CvPoint2D32f *cvdst = [self openCVMatrixWithQuadrilateral:destination];
    CvMat *dst_mat = cvCreateMat( 4, 2, CV_32FC1 );
    cvSetData(dst_mat, cvdst, sizeof(CvPoint2D32f));

    CvMat *H = cvCreateMat(3,3,CV_32FC1);
    cvFindHomography(src_mat, dst_mat, H);
    cvReleaseMat(&src_mat);
    cvReleaseMat(&dst_mat);

    CATransform3D transform = [self transform3DWithCMatrix:H->data.fl];
    cvReleaseMat(&H);

    return transform;
}

- (CvPoint2D32f*)openCVMatrixWithQuadrilateral:(Quadrilateral)origin {

    CvPoint2D32f *cvsrc = (CvPoint2D32f *)malloc(4*sizeof(CvPoint2D32f));
    cvsrc[0].x = origin.topLeft.x;
    cvsrc[0].y = origin.topLeft.y;
    cvsrc[1].x = origin.topRight.x;
    cvsrc[1].y = origin.topRight.y;
    cvsrc[2].x = origin.bottomRight.x;
    cvsrc[2].y = origin.bottomRight.y;
    cvsrc[3].x = origin.bottomLeft.x;
    cvsrc[3].y = origin.bottomLeft.y;

    return cvsrc;
}

-(CATransform3D)transform3DWithCMatrix:(float *)matrix {
    CATransform3D transform = CATransform3DIdentity;

    transform.m11 = matrix[0];
    transform.m21 = matrix[1];
    transform.m41 = matrix[2];

    transform.m12 = matrix[3];
    transform.m22 = matrix[4];
    transform.m42 = matrix[5];

    transform.m14 = matrix[6];
    transform.m24 = matrix[7];
    transform.m44 = matrix[8];

    return transform; 
}

mise à jour: je l'ai fait fonctionner correctement. Les coordonnées devaient provenir du Centre, pas de l'upperleft. J'ai appliqué xOffset et yOffset et viola. Code de démonstration à l'endroit mentionné ci-dessus ("demo" branch)

j'ai eu le même genre de problème et je l'ai corrigé en utilisant la fonction d'extraction d'homographie D'OpenCV.

vous pouvez voir comment je l'ai fait dans cette question: transformer une image rectangulaire en un quadrilatère en utilisant un CATransform3D

très inspiré de la réponse de @VaporwareWolf, implémentée en C# utilisant Xamarin MonoTouch pour iOS. La principale différence est que j'utilise GetPerspectiveTransform au lieu de FindHomography et TopLeft plutôt que ScaleToFit pour le mode contenu:

    void SetupWarpedImage(UIImage sourceImage, Quad sourceQuad, RectangleF destRectangle)
    {
        var imageContainerView = new UIView(destRectangle)
        {
            ClipsToBounds = true,
            ContentMode = UIViewContentMode.TopLeft
        };

        InsertSubview(imageContainerView, 0);

        var imageView = new UIImageView(imageContainerView.Bounds)
        {
            ContentMode = UIViewContentMode.TopLeft,
            Image = sourceImage
        };

        var offset = new PointF(-imageView.Bounds.Width / 2, -imageView.Bounds.Height / 2);
        var dest = imageView.Bounds;
        dest.Offset(offset);
        var destQuad = dest.ToQuad();

        var transformMatrix = Quad.GeneratePerspectiveTransformMatrixFromQuad(sourceQuad, destQuad);
        CATransform3D transform = transformMatrix.ToCATransform3D();

        imageView.Layer.AnchorPoint = new PointF(0f, 0f);
        imageView.Layer.Transform = transform;

        imageContainerView.Add(imageView);
    }