Mat rotation gets wrong result

edit

EDIT: adapted my own code a bit to get the desired result and make it more clear!

This is the code that I am using for rotating images around their center point

// Return the rotation matrices for each rotation
void rotate(Mat& src, double angle, Mat& dst)
{
    Point2f pt(src.cols/2., src.rows/2.);
    Mat r = getRotationMatrix2D(pt, angle, 1.0);
    warpAffine(src, dst, r, cv::Size(src.cols, src.rows));
}

And then in code you simply do something like this code snippet (tested with latest 2.4 OpenCV branch)

#include <iostream>
#include "opencv2/opencv.hpp"

using namespace std;
using namespace cv;

// Return the rotation matrices for each rotation
void rotate(Mat& src, double angle, Mat& dst)
{
    Point2f pt(src.cols/2., src.rows/2.);
    Mat r = getRotationMatrix2D(pt, angle, 1.0);
    warpAffine(src, dst, r, cv::Size(src.cols, src.rows));
}

int main()
{
    // Read in the image
    Mat input = imread("/data/test/image.jpg");
    imshow("input", input);

    // Make larger image
    int rows = input.rows;
    int cols = input.cols;
    int largest = 0;
    if ( rows > cols ){
        largest = rows;
    }else{
        largest = cols;
    }
    Mat temp = Mat::zeros(largest, largest, CV_8UC3);

    // Copy your original image
    // First define the roi in the large image --> draw this on a paper to make it clear
    // There are two possible cases
    Rect roi;
    if (input.rows > input.cols){
        roi = Rect((temp.cols - input.cols)/2, 0, input.cols, input.rows);
    }
    if (input.cols > input.rows){
        roi = Rect(0, (temp.rows - input.rows)/2, input.cols, input.rows);
    }

    // Copy the original to the black large temp image
    input.copyTo(temp(roi));

    // Rotate the image
    Mat rotated = temp.clone();
    rotate(temp, 90, rotated);

    imshow("rotated", rotated);

    // Now cut it out again
    Mat result = rotated(Rect(roi.y, roi.x, roi.height, roi.width)).clone();

    imshow("result", result);

    waitKey(0);
    return 0;
}

Which results into the following images in order [original - rotated - cropped result]

Just another solution. You can specify an arbitrary angle but not the center point of the rotation. The output size of the image is automatically calculated.

#include <iostream>
#include "opencv2/opencv.hpp"


// Return the rotation matrices for each rotation
void rotate(cv::Mat& src, double angle, cv::Mat& dst) {
  cv::Mat r = getRotationMatrix2D(cv::Point2f(), angle, 1.0);

  //4 coordinates of the image
  std::vector<cv::Point2f> corners(4);
  corners[0] = cv::Point2f(0, 0);
  corners[1] = cv::Point2f(0, src.rows);
  corners[2] = cv::Point2f(src.cols, 0);
  corners[3] = cv::Point2f(src.cols, src.rows);

  std::vector<cv::Point2f> cornersTransform(4);
  cv::transform(corners, cornersTransform, r);

  //Copy the 2x3 transformation matrix into a 3x3 transformation matrix
  cv::Mat H = cv::Mat::eye(3, 3, CV_64F);
  for(int i = 0; i < 2; i++) {
    for(int j = 0; j < 3; j++) {
      H.at<double>(i, j) = r.at<double>(i, j);
    }
  }

  double offsetX = 0.0, offsetY = 0.0, maxX = 0.0, maxY = 0.0;
  //Get max offset outside of the image and max width / height
  for(size_t i = 0; i < 4; i++) {
    if(cornersTransform[i].x < offsetX) {
      offsetX = cornersTransform[i].x;
    }

    if(cornersTransform[i].y < offsetY) {
      offsetY = cornersTransform[i].y;
    }

    if(cornersTransform[i].x > maxX) {
      maxX = cornersTransform[i].x;
    }

    if(cornersTransform[i].y > maxY) {
      maxY = cornersTransform[i].y;
    }
  }

  offsetX = -offsetX;
  offsetY = -offsetY;
  maxX += offsetX;
  maxY += offsetY;

  cv::Size size_warp(maxX, maxY);

  //Create the transformation matrix to be able to have all the pixels
  cv::Mat H2 = cv::Mat::eye(3, 3, CV_64F);
  H2.at<double>(0,2) = offsetX;
  H2.at<double>(1,2) = offsetY;

  warpPerspective(src, dst, H2*H, size_warp);
}

int main() {
  // Read in the image
  cv::Mat input;
  cv::VideoCapture capture("http://answers.opencv.org/upfiles/14303105806441826.jpg");
  if(!capture.isOpened()) {
    return -1;
  }
  capture >> input;
  if(input.empty()) {
    return -1;
  }

  cv::resize(input, input, cv::Size(), 0.5, 0.5);
  imshow("input", input);

  cv::Mat rotated;
  for(double angle = 0; angle < 360; angle += 1.0) {
    rotate(input, angle, rotated);
    cv::imshow("rotated", rotated);
    char c = cv::waitKey(30);
    if(c == 27) {
      break;
    }
  }

  return 0;
}