Rotation cv:: Mat en utilisant cv:: warpaffine offsets destination image

beaucoup de gens ont eu des problèmes avec les images tournantes ou des morceaux d'image en raison des décalages, etc. Donc, je poste une solution pour vous permettre de faire tourner une région (ou un ensemble) d'une image et de la coller dans une autre image ou avoir la fonction Calculer une image où tout ira bien.

// ROTATE p by R
/**
 * Rotate p according to rotation matrix (from getRotationMatrix2D()) R
 * @param R     Rotation matrix from getRotationMatrix2D()
 * @param p     Point2f to rotate
 * @return      Returns rotated coordinates in a Point2f
 */
Point2f rotPoint(const Mat &R, const Point2f &p)
{
    Point2f rp;
    rp.x = (float)(R.at<double>(0,0)*p.x + R.at<double>(0,1)*p.y + R.at<double>(0,2));
    rp.y = (float)(R.at<double>(1,0)*p.x + R.at<double>(1,1)*p.y + R.at<double>(1,2));
    return rp;
}

//COMPUTE THE SIZE NEEDED TO LOSSLESSLY STORE A ROTATED IMAGE
/**
 * Return the size needed to contain bounding box bb when rotated by R
 * @param R     Rotation matrix from getRotationMatrix2D()
 * @param bb    bounding box rectangle to be rotated by R
 * @return      Size of image(width,height) that will compleley contain bb when rotated by R
 */
Size rotatedImageBB(const Mat &R, const Rect &bb)
{
    //Rotate the rectangle coordinates
    vector<Point2f> rp;
    rp.push_back(rotPoint(R,Point2f(bb.x,bb.y)));
    rp.push_back(rotPoint(R,Point2f(bb.x + bb.width,bb.y)));
    rp.push_back(rotPoint(R,Point2f(bb.x + bb.width,bb.y+bb.height)));
    rp.push_back(rotPoint(R,Point2f(bb.x,bb.y+bb.height)));
    //Find float bounding box r
    float x = rp[0].x;
    float y = rp[0].y;
    float left = x, right = x, up = y, down = y;
    for(int i = 1; i<4; ++i)
    {
        x = rp[i].x;
        y = rp[i].y;
        if(left > x) left = x;
        if(right < x) right = x;
        if(up > y) up = y;
        if(down < y) down = y;
    }
    int w = (int)(right - left + 0.5);
    int h = (int)(down - up + 0.5);
    return Size(w,h);
}

/**
 * Rotate region "fromroi" in image "fromI" a total of "angle" degrees and put it in "toI" if toI exists.
 * If toI doesn't exist, create it such that it will hold the entire rotated region. Return toI, rotated imge
 *   This will put the rotated fromroi piece of fromI into the toI image
 *
 * @param fromI     Input image to be rotated
 * @param toI       Output image if provided, (else if &toI = 0, it will create a Mat fill it with the rotated image roi, and return it).
 * @param fromroi   roi region in fromI to be rotated.
 * @param angle     Angle in degrees to rotate
 * @return          Rotated image (you can ignore if you passed in toI
 */
Mat rotateImage(const Mat &fromI, Mat *toI, const Rect &fromroi, double angle)
{
    //CHECK STUFF
    // you should protect against bad parameters here ... omitted ...

    //MAKE OR GET THE "toI" MATRIX
    Point2f cx((float)fromroi.x + (float)fromroi.width/2.0,fromroi.y +
               (float)fromroi.height/2.0);
    Mat R = getRotationMatrix2D(cx,angle,1);
    Mat rotI;
    if(toI)
        rotI = *toI;
    else
    {
        Size rs = rotatedImageBB(R, fromroi);
        rotI.create(rs,fromI.type());
    }

    //ADJUST FOR SHIFTS
    double wdiff = (double)((cx.x - rotI.cols/2.0));
    double hdiff = (double)((cx.y - rotI.rows/2.0));
    R.at<double>(0,2) -= wdiff; //Adjust the rotation point to the middle of the dst image
    R.at<double>(1,2) -= hdiff;

    //ROTATE
    warpAffine(fromI, rotI, R, rotI.size(), INTER_CUBIC, BORDER_CONSTANT, Scalar::all(0)); 

    //& OUT
    return(rotI);
}

je me rends compte que vous avez trouvé d'autres solutions plus rapides (la rotation de 90 degrés devrait être très rapide, et n'a pas besoin de toutes les machines de warpAffine), mais je veux aborder le problème de la frontière noire pour toute autre personne qui court à travers cela.

que pouvait faire warpAffine? L'image de destination a été spécifiée pour être plus large qu'elle n'était haute, et la transformation affine a seulement spécifié la rotation (autour du centre de l'image), pas l'échelle. C'est exactement ce qu'il fait. Il est aucune information ne dit à warpAffine ce qui doit être dessiné dans ces frontières noires, donc il les a laissés noirs.

physique Directe de l'expérience: Mettre une feuille sur la table. Dessinez un contour autour (c'est ce que vous avez fait quand vous avez spécifié que vous vouliez que le résultat soit la même forme/taille que l'original). Maintenant, faites pivoter cette feuille de 90 degrés autour de son centre. Regardez la région délimitée par le contour sur la table. Si c'était un noir tableau, il ressemblerait exactement comme votre résultat.

peut-être que ça peut aider quelqu'un.

les variables sont

img: image originale

angle: degrés

échelle

dst: image de la destination

int width = img.size().width, 
    height = img.size().height;
Mat rot = getRotationMatrix2D(Point2f(0,0), angle, scale)/scale; //scale later
double sinv = rot.at<double>(0,1),
       cosv = rot.at<double>(0,0);
rot.at<double>(1,2) = width*sinv;  //adjust row offset
Size dstSize(width*cosv + height*sinv, width*sinv + height*cosv);
Mat dst;
warpAffine(img, dst, rot, dstSize);
resize(dst, dst, Size(), scale, scale);  //scale now

un problème que j'ai trouvé, c'est que la taille de l'image de destination pour warpAffine est définie à image.size() au lieu de rotated_img.size() . Cependant, après la chaîne, il est encore traduit trop loin dans x et y ...J'ai essayé la même distorsion

[ 6.123031769111886e-17 1                     163.9999999999999;
 -1                     6.123031769111886e-17 1132;
  0                     0                     1]

d'Opencv's getroationmatrix2d dans Matlab, et ça a fonctionné parfaitement. Je commence à sentir un bug possible avec warpAffine ...