C++ 方法中的图像旋转答案

【问题标题】：Image Rotation in a C++ MethodC++ 方法中的图像旋转
【发布时间】：2014-02-25 18:05:59
【问题描述】：

我之前在 Stack Overflow 上发布过关于如何在 c++ 程序中准确旋转 BMP 图像的问题。然而，现在，关于我的进步，我还有更多要展示的东西。

我想知道我的程序如何（或为什么）在我进行图像计算后不会输出图像：

void BMPImage::Rotate45Left(float point1, float point2, float point3)
{
  float radians = (2 * 3.1416*45) / 360;

  float cosine = (float)cos(radians);
  float sine = (float)sin(radians);

  float point1Xtreme = 0;
  float point1Yearly = 0;
  float point2Xtreme = 0;
  float point2Yearly = 0;
  float point3Xtreme = 0;
  float point3Yearly = 0;

int SourceBitmapHeight = m_BIH.biHeight;
int SourceBitmapWidth = m_BIH.biWidth;

point1Xtreme = (-m_BIH.biHeight*sine);
point1Yearly = (m_BIH.biHeight*cosine);
point2Xtreme = (m_BIH.biWidth*cosine - m_BIH.biHeight*sine);
point2Yearly = (m_BIH.biHeight*cosine + m_BIH.biWidth*sine);
point3Xtreme = (m_BIH.biWidth*cosine);
point3Yearly = (m_BIH.biWidth*sine);

float Minx = min(0, min(point1Xtreme, min(point2Xtreme, point3Xtreme)));
float Miny = min(0, min(point1Yearly, min(point2Yearly, point3Yearly)));
float Maxx = max(point1Xtreme, max(point2Xtreme, point3Xtreme));
float Maxy = max(point1Yearly, max(point2Yearly, point3Yearly));

int FinalBitmapWidth = (int)ceil(fabs(Maxx) - Minx);
int FinalBitmapHeight = (int)ceil(fabs(Maxy) - Miny);
FinalBitmapHeight = m_BIH.biHeight;
FinalBitmapWidth = m_BIH.biWidth;
int finalBitmap;

如果有人有任何有用的指点，那就太好了。我应该提一下：

我不能将其他外部库用于此程序
这是一个小型的图像处理程序，有一个菜单系统

【问题讨论】：

您的代码似乎根本没有进行任何旋转，因此没有图像输出是预期的结果。
顺便说一句，我发布上述内容的目的是在所以我们不是来为您做作业的。如果您发布试图解决问题但无法按预期工作的真实代码，我们可以提供帮助。您发布的代码甚至没有开始旋转图像。甚至没有要旋转的图像..

标签： c++ image image-processing image-rotation

【解决方案1】：

图像转换通常通过将目标像素投影到源像素上然后计算该目标像素的值来完成。这样您就可以轻松地合并不同的插值方法。

template <typename T>
struct Image {
    Image(T* data, size_t rows, size_t cols) : 
        data_(data), rows_(rows), cols_(cols) {}
    T* data_;
    size_t rows_;
    size_t cols_;
    T& operator()(size_t row, size_t col) {
        return data_[col + row * cols_];
    }
 };

template <typename T>
T clamp(T value, T lower_bound, T upper_bound) {
    value = std::min(std::max(value, lower_bound), upper_bound);
}

void rotate_image(Image const &src, Image &dst, float ang) {
    // Affine transformation matrix 
    // H = [a, b, c]
    //     [d, e, f]

    // Remember, we are transforming from destination to source, 
    // thus the negated angle. 
    float H[] = {cos(-ang), -sin(-ang), dst.cols_/2 - src.cols_*cos(-ang)/2,
                 sin(-ang),  cos(-ang), dst.rows_/2 - src.rows_*cos(-ang)/2}; 


    for (size_t row = 0; row < dst.rows_; ++row) {
       for (size_t col = 0; col < dst.cols_; ++cols) {
           int src_col = round(H[0] * col + H[1] * row + H[2]);
           src_col = clamp(src_col, 0, src.cols_ - 1);
           int src_row = round(H[3] * col + H[4] * row + H[5]);
           src_row = clamp(src_row, 0, src.rows_ - 1);               

           dst(row, col) = src(src_row, src_col);
       }
    }
}

上述方法以任意角度旋转图像并使用最近邻插值。我直接在stackoverflow中输入了，所以漏洞百出；然而，这个概念是存在的。

【讨论】：