在嵌入式 C 应用程序中，我有一个大图像，我想将其旋转 90 度。 目前我使用众所周知的简单算法来做到这一点。然而，这个算法要求我制作图像的另一个副本。 我想避免为副本分配内存，我宁愿就地旋转它。 由于图像不是正方形，这很棘手。 有谁知道合适的算法吗？
编辑添加澄清，因为人们在问：
我以通常的格式存储图像：
// Images are 16 bpp
struct Image {
int width;
int height;
uint16_t * data;
};
uint16_t getPixel(Image *img, int x, int y)
{
return img->data[y * img->width + x];
}
我希望移动
datawidthheight这可能有帮助：就地矩阵转置。
（如 rlbond 提到的，在转置后您可能还需要进行一些镜像）。
如果您以“错误的顺序”从内存中读取图像，则本质上与旋转图像相同。这可能适合也可能不适合你正在做的任何事情，但这里是：
image[y][x] /* assuming this is the original orientation */
image[x][original_width - y] /* rotated 90 degrees ccw */
image[original_height - x][y] /* 90 degrees cw */
image[original_height - y][original_width - x] /* 180 degrees */
不确定旋转后你会做什么处理，但你可以不管它并使用另一个函数从原始内存中读取旋转的像素。
uint16_t getPixel90(Image *img, int x, int y)
{
return img->data[(img->height - x) * img->width + y];
}
输入参数 x 和 y 已交换原始尺寸
这个问题花了我相当长的时间，但如果你有正确的方法，它是非常简单的。
注意这仅适用于方阵。矩形将要求您使用其他算法（转置和翻转）。如果您想就地执行此操作，可能需要您暂时调整数组的大小。
考虑以下矩阵：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
旋转 90 度，只看角（数字 1、4、16 和 13）。如果您在可视化它时遇到问题，请用便利贴帮助自己。
现在，让我们考虑以下问题：
1 - - 2
- - - -
- - - -
4 - - 3
将其旋转 90 度，注意数字如何以循环方式旋转：2 变为 1，3 变为 2，4 变为 3，1 变为 4。
为了旋转角点，需要根据第一个角点定义所有角点：
(i, j)(SIZE - j, i)(SIZE - i, SIZE - j)(j, SIZE - i)请注意，数组是从 0 开始的，因此
SIZE现在您已经了解了旋转角的概念，我们将把“旋转角”的概念扩展到“旋转象限”。同样的原理也成立。
您需要确保没有数字被覆盖。这意味着，您需要同时旋转 4 个数字。
#include <algorithm>
#include <numeric>
#include <vector>
using std::iota;
using std::swap;
using std::vector;
// Rotates 4 numbers.
// e.g: 1, 2, 3, 4 becomes 4, 1, 2, 3
// int& means numbers are passed by reference, not copy.
void rotate4(int &a, int &b, int &c, int &d)
{
swap(a, b);
swap(b, c);
swap(c, d);
}
void rotateMatrix(vector<vector<int>>& m) {
int n = m.size();
// NOTE: i and j from 0 to n/2 is a quadrant
for (int i = 0; i < n/2; i++) {
// NOTE : here + 1 is added to make it work when n is odd
for (int j = 0; j < (n + 1)/2; j++) {
int r_i = (n - 1) - i;
int r_j = (n - 1) - j;
rotate4(
m [i] [j],
m [r_j] [i],
m [r_i] [r_j],
m [j] [r_i]
);
}
}
}
void fillMatrix(vector<vector<int>>& m) {
int offset = 0;
for (auto &i : m) {
iota(i.begin(), i.end(), offset);
offset += i.size();
}
}
// Usage:
const int size = 8;
vector<vector<int>> matrix (size, vector<int>(size));
fillMatrix(matrix);
rotateMatrix(matrix);
要打印矩阵，您可以使用：
#include <algorithm>
#include <iostream>
#include <iterator>
using std::copy;
using std::cout;
using std::ostream;
using std::ostream_iterator;
using std::vector;
ostream& operator<<(ostream& os, vector<vector<int>>& m) {
for (auto const &i : m) {
copy(i.begin(), i.end(), ostream_iterator<int>(os, " "));
os << "\n";
}
return os;
}
// Usage
cout << matrix;
这可能太模糊了，不是您要找的，但无论如何我都会发布。
如果您将图像视为二维像素数组，则只需反转顶层或嵌套数组的顺序，具体取决于您想要水平还是垂直翻转..
因此，您可以循环遍历每个像素列（0->列/2）并交换它们（因此您只需要 1 个像素的临时内存，而不是整个图片），或者循环遍历行以进行水平翻转。有道理吗？如果没有，将详细说明/编写代码..
真正的答案：不，如果不分配一些内存就不能。
或者你必须使用递归，这对于大图像来说会失败。
但是有些方法需要的内存少于图像本身
例如，您可以获取点 A（x 从 0 到宽度，y 从 0 到高度），计算它的新位置 B，将 B 复制到新位置 (C)，然后将其替换为 A，等等。
但是，该方法需要跟踪已移动的字节。 （在旋转图像中使用每像素一位的位图）
参见维基百科文章，它清楚地表明对于非方形图像不能这样做：这里又是链接：http://en.wikipedia.org/wiki/In-place_matrix_transposition
这是一个简单的java方法，
public static void rotateMatrix(int[][] a) {
int m =0;
for(int i=0; i<a.length; ++i) {
for(int j=m; j<a[0].length; ++j) {
int tmp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = tmp;
}
m++;
}
for(int i=0; i<a.length; ++i) {
int end = a.length-1;
for(int j=0; j<a[0].length; j++) {
if(j>=end)
break;
int tmp = a[i][j];
a[i][j] = a[i][end];
a[i][end] = tmp;
end--;
}
}
}
您可以通过将 (x, y) 坐标展平为单个索引来简单地实现旋转 90 度矩阵，将 2D 图像视为 1D 数组。
// Images are 16 bpp
struct Image {
int width;
int height;
uint16_t * data;
};
int getIndex(int x, int y, int width) {
return y * width + x;
}
int rotateIndex(int x, int y, int originalWidth, int originalHeight) {
return getIndex(y, originalWidth - 1 - x, originalHeight);
}
void rotate90Image(struct Image *img) {
int originalWidth = img->width;
int originalHeight = img->height;
int totalPixels = originalWidth * originalHeight;
// temporary pixel data during swaps
uint16_t temp;
// swap until all pixels are rotated
for (int start = 0; start < totalPixels; start++) {
int current = start;
int x = current % originalWidth;
int y = current / originalWidth;
int nextIndex = rotateIndex(x, y, originalWidth, originalHeight);
// Continue the cycle until the pixel reaches its final position
if (nextIndex != start) {
temp = img->data[current];
while (nextIndex != start) {
img->data[current] = img->data[nextIndex];
current = nextIndex;
x = current % originalWidth;
y = current / originalWidth;
nextIndex = rotateIndex(x, y, originalWidth, originalHeight);
}
img->data[current] = temp;
}
}
// swap the width and height to reflect the rotated image
int tempDim = img->width;
img->width = img->height;
img->height = tempDim;
}
这类似于二维矩阵的旋转。下面是我的算法，它将 2D 矩阵旋转 90 度。它也适用于 M X N。对给定矩阵进行转置，然后将第一列与最后一列交换，将第二列与倒数第二列交换，依此类推。您还可以使用行而不是列。
import java.io.*;
import java.util.*;
public class MatrixRotationTest
{
public static void main(String arg[])throws Exception
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the matrix rows:");
int r = Integer.parseInt(br.readLine());
System.out.println("Enter the matrix columns:");
int c = Integer.parseInt(br.readLine());
int[][] matrix = new int[r*c][r*c];
for(int i=0;i<r;i++)
{
System.out.println("Enter row "+(i+1));
for(int j=0;j<c;j++)
{
matrix[i][j] = Integer.parseInt(br.readLine());
}
}
matrix = reverseMatrixColumns(transformMatrix(matrix),r,c);
System.out.println("Rotated Matrix");
for(int i=0;i<c;i++)
{
for(int j=0;j<r;j++)
{
System.out.print(matrix[i][j]+" ");
}
System.out.println();
}
}
//Transform the given matrix
public static int[][] transformMatrix(int[][] matrix)throws Exception
{
for(int i=0;i<matrix.length;i++)
{
for(int j=i;j<matrix[0].length;j++)
{
int temp = matrix[i][j];
matrix[i][j] = matrix [j][i];
matrix[j][i] = temp;
}
}
}
//Swap columns
public static int[][] reverseMatrixColumns(int[][] matrix,int r,int c)
{
int i=0,j=r-1;
while(i!=r/2)
{
for(int l=0;l<c;l++)
{
int temp = matrix[l][i];
matrix[l][i] = matrix[l][j];
matrix[l][j] = temp;
}
i++;
j--;
}
return matrix;
}
}
这是我对矩阵 90 度旋转的尝试，这是 C 中的两步解决方案。
首先将矩阵转置到位，然后交换列。
#define ROWS 5
#define COLS 5
void print_matrix_b(int B[][COLS], int rows, int cols)
{
for (int i = 0; i <= rows; i++) {
for (int j = 0; j <=cols; j++) {
printf("%d ", B[i][j]);
}
printf("\n");
}
}
void swap_columns(int B[][COLS], int l, int r, int rows)
{
int tmp;
for (int i = 0; i <= rows; i++) {
tmp = B[i][l];
B[i][l] = B[i][r];
B[i][r] = tmp;
}
}
void matrix_2d_rotation(int B[][COLS], int rows, int cols)
{
int tmp;
// Transpose the matrix first
for (int i = 0; i <= rows; i++) {
for (int j = i; j <=cols; j++) {
tmp = B[i][j];
B[i][j] = B[j][i];
B[j][i] = tmp;
}
}
// Swap the first and last col and continue until
// the middle.
for (int i = 0; i < (cols / 2); i++)
swap_columns(B, i, cols - i, rows);
}
int _tmain(int argc, _TCHAR* argv[])
{
int B[ROWS][COLS] = {
{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15},
{16, 17, 18, 19, 20},
{21, 22, 23, 24, 25}
};
matrix_2d_rotation(B, ROWS - 1, COLS - 1);
print_matrix_b(B, ROWS - 1, COLS -1);
return 0;
}