Ну, я знаю, что постер явно просил цикл for, и ответ Джеффа Мэзера дал именно это.

Но все же мне стало любопытно, можно ли без цикла разложить матрицу на плитки (субматрицы) заданного размера. Если кому-то тоже интересно, вот что у меня получилось:

T = permute(reshape(permute(reshape(A, size(A, 1), n, []), [2 1 3]), n, m, []), [2 1 3])

преобразует двумерный массив A в трехмерный массив T, где каждый 2d-срез T(:, :, i) является одной из плиток размером m x n. Третий индекс перечисляет плитки в стандартном линеаризованном порядке Matlab, сначала строки плитки.

Вариант

T = permute(reshape(A, size(A, 1), n, []), [2 1 3]);
T = permute(reshape(T, n, m, [], size(T, 3)), [2 1 3 4]);

делает T четырехмерным массивом, где T(:, :, i, j) дает 2d-срез с индексами плитки i, j.

Придумывать эти выражения немного похоже на решение скользящей головоломки. ;-)

Мне жаль, что в моем ответе также не используется цикл for, но это тоже поможет:

cellOf20x20matrices = mat2cell(matrix, ones(1,20)*20, ones(1,20)*20)

Затем вы можете получить доступ к отдельным ячейкам, например:

cellOf20x20matrices{i,j}(a,b)

где i,j — это подматрица для извлечения (и a, b — индексация в эту матрицу, если необходимо)

С уважением

Ты кажешься очень близким. Просто используя проблему, как вы ее описали (400 на 400, разделенную на куски 20 на 20), разве это не сделает то, что вы хотите?

[x,y] = size(M);

for i = 1:20:x
  for j = 1:20:y
    tmp = M(i:(i+19), j:(j+19));
    % Do something interesting with "tmp" here.
  end
end

Несмотря на то, что вопрос в основном касается 2D-матриц, вдохновленных A. Ответ Донды Я хотел бы расширить его ответ на 3D-матрицы, чтобы этот метод можно было использовать при кадрировании изображений True Color (3D)

A = imread('peppers.png');       %// size(384x512x3)
nCol = 4;                        %// number of Col blocks
nRow = 2;                        %// number of Row blocks
m = size(A,1)/nRow;              %// Sub-matrix row size (Should be an integer)
n = size(A,2)/nCol;              %// Sub-matrix column size (Should be an integer)

imshow(A);                       %// show original image

out1 = reshape(permute(A,[2 1 4 3]),size(A,2),m,[],size(A,3));
out2 = permute(reshape(permute(out1,[2 1 3 4]),m,n,[],size(A,3)),[1 2 4 3]);

figure;
for i = 1:nCol*nRow
    subplot(nRow,nCol,i); imshow(out2(:,:,:,i));
end

Основная идея состоит в том, чтобы при изменении формы не затрагивать 3-е измерение, чтобы изображение не искажалось. Для этого была сделана дополнительная перестановка, чтобы поменять местами 3-е и 4-е измерения. Как только процесс завершен, размеры восстанавливаются как были путем перестановки обратно.

Результаты:

Исходное изображение

Подграфики (разделы/подматрицы)

Преимущество этого метода в том, что он хорошо работает и с 2D-изображениями. Вот пример изображения в градациях серого (2D). В качестве примера здесь используется встроенный образ MatLab 'cameraman.tif'

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

Это правда, что они не возвращают одно и то же, но:

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

Во всяком случае, я сравнил их обоих со следующим сценарием. Код запускался в Octave (версия 3.9.1) с отключенным JIT.

function T = split_by_reshape_permute (A, m, n)
  T = permute (reshape (permute (reshape (A, size (A, 1), n, []), [2 1 3]), n, m, []), [2 1 3]);
endfunction

function T = split_by_mat2cell (A, m, n)
  l = size (A) ./ [m n];
  T = mat2cell (A, repmat (m, l(1), 1), repmat (n, l (2), 1));
endfunction

function t = time_it (f, varargin)
  t = cputime ();
  for i = 1:100
    f(varargin{:});
  endfor
  t = cputime () - t;
endfunction

Asizes = [30 50 80 100 300 500 800 1000 3000 5000 8000 10000];
Tsides = [2 5 10];
As = arrayfun (@rand, Asizes, "UniformOutput", false);

for d = Tsides
  figure ();

  t1 = t2 = [];
  for A = As
    A = A{1};
    s = rows (A) /d;

    t1(end+1) = time_it (@split_by_reshape_permute, A, s, s);
    t2(end+1) = time_it (@split_by_mat2cell, A, s, s);

  endfor

  semilogy (Asizes, [t1(:) t2(:)]);
  title (sprintf ("Splitting in %i", d));
  legend ("reshape-permute", "mat2cell");
  xlabel ("Length of matrix side (all squares)");
  ylabel ("log (CPU time)");
endfor

Обратите внимание, что ось Y находится в логарифмическом масштабе.

Представление

С точки зрения производительности использование вложенной перестановки будет быстрее только для меньших матриц, где большие изменения относительной производительности на самом деле являются очень небольшими изменениями во времени. Обратите внимание, что ось Y представлена ​​в логарифмическом масштабе, поэтому разница между двумя функциями для матрицы 100 x 100 – 0,02 секунды, а для матрицы 10 000 x 10 000 – 100 секунд.

Я также протестировал следующее, которое преобразует ячейку в матрицу, чтобы возвращаемые значения двух функций были одинаковыми:

function T = split_by_mat2cell (A, m, n)
  l = size (A) ./ [m n];
  T = mat2cell (A, repmat (m, l(1), 1), repmat (n, l (2), 1), 1);
  T = reshape (cell2mat (T(:)'), [m n numel(T)]);
endfunction

Это немного замедляет его, но не настолько, чтобы учитывать (линии будут пересекаться при разрешении 600 x 600 вместо 400 x 400).

Читабельность

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

Будущее

Вложенные вызовы permute вообще плохо расширяются в N измерений. Я предполагаю, что для этого потребуется цикл for по измерению (что совсем не поможет и без того довольно загадочному коду). С другой стороны, используя mat2cell:

function T = split_by_mat2cell (A, lengths)
  dl = arrayfun (@(l, s) repmat (l, s, 1), lengths, size (A) ./ lengths, "UniformOutput", false);
  T = mat2cell (A, dl{:});
endfunction

Изменить (и протестировать в Matlab)

Количество голосов за ответ, предлагающий использовать перестановку и изменение формы, вызвало у меня такое любопытство, что я решил протестировать это в Matlab (R2010b). Результаты там были почти такими же, т. Е. Производительность действительно плохая. Поэтому, если эта операция не будет выполняться много раз, в матрицах, которые всегда будут маленькими (менее 300x300), и всегда будет гуру Matlab, который объяснит, что она делает, не делайте этого. используй это.

Если вы хотите использовать цикл for, вы можете сделать это:

[x,y] = size(matrix)

k=1; % counter

for i = 1:20:x
    for j = 1:20:y

        subMatrix=Matrix(i:i+19, j:j+19);

        subMatrixCell{k}=subMatrix;  % if you want to save all the
                                    % submatrices into a cell array
        k=k+1;

    end
end