Поворот cv:: Mat с использованием cv:: warpAffine смещает изображение цели

Ответ 1

У меня найдено решение, которое не включает warpAffine().

Но перед этим мне нужно указать (для будущих ссылок), что мое подозрение было правильным, вам нужно было передать размер адресата при вызове warpAffine():

warpAffine(image, rotated_img, rot_matrix, rotated_img.size());

Насколько я могу судить, черная рамка (вызванная записью со смещением), созданная этой функцией, кажется стандартным. Я заметил это с интерфейсом C, а также с С++-интерфейсом OpenCV, работающим на Mac и Linux, с использованием версий 2.3.1a и 2.3.0.

Решение, которое я в конечном итоге использовал, намного проще, чем все это. Вы можете использовать cv::transpose() и cv::flip() для поворота изображение на 90 градусов. Вот он:

Mat src = imread(argv[1], 1);

cv::Mat dst;
cv::transpose(src, dst);
cv::flip(dst, dst, 1);

imwrite("rotated90.jpg", dst);

---- I >

Ответ 2

У многих людей были проблемы с вращающимися изображениями или фрагментами изображений из-за смещений и т.д. Итак, я отправляю решение, позволяющее поворачивать область (или целое) изображения и вставлять его в другое изображение или функция выполняет вычисление изображения, где все будет просто соответствовать.

// 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);
}

Ответ 3

Я понимаю, что вы нашли другие более быстрые решения (поворот на 90 градусов должен быть очень быстрым и не нужен всем механизмом warpAffine), но я хочу решить проблему черной границы для всех, кто сталкивается с этим.

Что еще может сделать warpAffine? Целевое изображение было указано более широким, чем оно было высоким, а аффинное преобразование определяло только вращение (вокруг центра изображения), а не масштабирование. Это именно то, что он сделал. Нет никакой информации, чтобы сообщить warpAffine, что должно быть нарисовано в этих черных границах, поэтому оно оставило их черными.

Прямой физический эксперимент: Поместите лист вниз на стол. Нарисуйте схему вокруг нее (это то, что вы сделали, когда указали, что хотите, чтобы результат был того же размера/размера, что и оригинал). Теперь поверните этот лист на 90 градусов вокруг его центра. Посмотрите на область, связанную контуром на столе. Если бы это был черный стол, он выглядел бы точно так же, как и ваш результат.

Ответ 4

Возможно, это может помочь кому-то. переменные - img: оригинальное изображение
угол: градус
масштаб
dst: изображение назначения

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

Ответ 5

Одна из проблем, которые я обнаружил, заключается в том, что размер целевого изображения для warpAffine установлен в image.size() вместо rotated_img.size(). Однако после warp он все еще переведен слишком далеко в x и y... Я пробовал тот же самый warp

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

из OpenCV getRotationMatrix2D в Matlab, и он отлично работал. Я начинаю запах возможной ошибки с помощью warpAffine...