Как транспонировать растровое изображение на месте в C++

Я думаю, что проблема более сложна, чем вы думаете, и это не просто случай замены пикселей в x, y на пиксели в y, x. Если вы рассматриваете изображение размером 3 * 7 пикселей, в котором я пометил пиксели a-u:

abcdefg
hijklmn
opqrstu

Вращение этого изображения дает:

aho
bip
cjq
dkr
els
fmt
gnu

Превращение обоих изображений в одномерный массив дает:

abcdefghijklmnopqrstu

ahobipcjqdkrelsfmtgnu

Обратите внимание, что b переместилось на позицию d, но было заменено на h.

Переосмыслите свой алгоритм, нарисуйте его для небольшого изображения и убедитесь, что он работает, прежде чем пытаться его реализовать.

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

В основном эквивалентный код, который должно быть легче отлаживать:

inline uint32_t * addr(uint8_t* buffer, const uint32_t width, uint32_t i, uint32_t j) {
    uint32_t * tmp = buffer;
    return tmp+i*width+j;
}

void transpose(uint8_t* buffer, const uint32_t width, const uint32_t height) {
    for (uint32_t i = 0; i < min(width,height); i++) {
        for (uint32_t j = 0; j < i; j++) {
            uint32_t * a = addr(buffer, width, i, j);
            uint32_t * b = addr(buffer, width, j, i);
            const uint32_t tmp = *a;
            *a = *b;
            *b = tmp;
        }
    }
}

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

Обратите внимание, что перенос матрицы на место не является тривиальным, когда N!=M. Подробнее см., например, здесь.

Причина в том, что при N=M можно просто перебрать половину матрицы и поменять местами элементы. Когда N!=M это не так.

Для иллюстрации рассмотрим более простой случай:

Сначала 2D-просмотр 1D-данных:

struct my2dview {
    std::vector<int>& data;
    int width,height;
    my2dview(std::vector<int>& data,int width,int height):data(data),width(width),height(height){}
    int operator()(int x,int y) const { return data[x*width + y]; }
    int& operator()(int x,int y){ return data[x*width + y]; }
    my2dview get_transposed() { return my2dview(data,height,width);}
};


std::ostream& operator<<(std::ostream& out, const my2dview& x){
    for (int h=0;h<x.height;++h){
        for (int w=0;w<x.width;++w){
            out << x(h,w) << " ";
        }
        out << "\n";
    }
    return out;
}

Теперь транспонирование, которое будет работать для N=M:

my2dview broken_transpose(my2dview x){
    auto res = x.get_transposed();
    for (int i=0;i<x.height;++i){
        for (int j=0;j<x.width;++j){
            res(j,i) = x(i,j);
        }
    }
    return res;
}

Использование его для небольшой матрицы

int main() {
    std::vector<int> x{1,2,3,4,5,6};
    auto v = my2dview(x,2,3);
    std::cout << v << '\n';
    std::cout << v.get_transposed() << '\n';
    auto v2 = broken_transpose(v);
    std::cout << v2;
}

отпечатки

1 2
3 4
5 6

1 2 3
4 5 6

1 3 2
2 2 6

Вывод: наивный подход с заменой элементов не работает для неквадратных матриц.

На самом деле этот ответ просто перефразирует ответ @Alan Birtles. Я чувствовал вызов его

Из-за сложности задачи может оказаться, что быстрее создать временный [...]

просто чтобы прийти к такому же выводу ;).