Início / coding / Perguntas / 79365295
Accepted
the_wicked
Asked: 2025-01-17 23:36:47 +0800 CST

Como dividir uma matriz no MATLAB em N^2 segmentos, cada um com NxN elementos?

  • 772

Supondo que temos uma matriz M de tamanho N^2 x N^2 elementos (por exemplo, 9x9), qual é a maneira mais rápida de dividi-la em segmentos de 3x3 (cada um com 3x3 elementos)?

Uma maneira que me vem à mente é a seguinte:

M = magic(9);
N = 3; 

m = mat2cell(M, N * ones(1, size(M, 1) / N), ...
                N * ones(1, size(M, 2) / N));

Eu, no entanto, não prefiro o uso de células. Fiquei curioso para saber se há uma maneira de dividir a matriz e armazenar os segmentos na forma de uma matriz 3D usando uma indexação de coluna principal para os segmentos (por exemplo, o primeiro segmento m{1} se torna m(:, :, 1) e o segundo segmento m{2} se torna m(:, :, 2), e assim por diante).

arrays

4 respostas

  1. Best Answer

    Você pode combinar reshapecom permute, por exemplo assim:

    reshape(permute(reshape(M, N,N,N,N), [1,3, 2,4]), N,N, N*N)

    O interior reshapetem as "células" pretendidas divididas nas dimensões 1 e 3, que permutemudam para as dimensões 1 e 2. O exterior reshapepode ser omitido, se você não se importar em ter uma matriz 4D.

    • 7

  2. Depois de usar mat2cell, você pode concatenar as matrizes 2D em uma matriz 3D com

    m = cat( 3, m{:} );

    Isso irá satisfazer "m{1} se torna m(:, :, 1)" etc.

    Uma opção diferente seria pegar cada faixa de Nlinhas e reshapecolocá-las diretamente em uma NxNxNmatriz de segmentos, atribuindo-as como o próximo pedaço da NxNx(N^2)matriz de saída.

    m = NaN(N,N,N^2);
for ii = 1:N:N^2
    m(:,:,ii:(ii+N-1)) = reshape( M(ii:(ii+N-1),:), N, N, N );
end

    Note que os segmentos nessas duas opções estão em uma ordem diferente (o primeiro vai para baixo e depois para as submatrizes, o último vai para o outro lado e depois para baixo). Se você quisesse que esse loop e a versão de remodelagem correspondessem mat2cellexatamente à versão, você precisaria fazer algumas operações de transposição com o reshapepara obter a ordem correta

    m = NaN(N,N,N^2);
for ii = 1:N:N^2
    m(:,:,ii:(ii+N-1)) = pagetranspose( reshape( M(:,ii:(ii+N-1)).', N, N, N ) );
end

    Há apenas uma pequena perda de desempenho ao realizar operações de transposição adicionais.

    Atualização com benchmarking

    Fiquei curioso sobre qual das opções acima seria mais rápida, então escrevi o benchmark na parte inferior aqui (wrapper para o código sugerido na resposta acima). Aqui está o gráfico resultante, então fazer um loop e atribuir diretamente em uma matriz numérica é mais rápido do que passar por uma célula, independentemente de N:

    Também incluí a resposta de chtz que usa apenas reshapee permuta, e fornece o mesmo resultado que as opções mat2celle pagetransposeacima, muito mais rápido e com menos dependência de N, então eu recomendaria a solução deles .

    resultados de benchmarking

    Código de benchmarking:

    Nmax = 17;
t = zeros(Nmax,2);
for N = 2:Nmax
    M = (1:N^2) + 0.1*(1:N^2).';
    
    t(N,1) = timeit( @() opt1(N,M) );
    t(N,2) = timeit( @() opt2(N,M) );
    t(N,3) = timeit( @() opt3(N,M) );
    t(N,4) = timeit( @() opt4(N,M) );
end

figure(1); clf; hold on; grid on; legend( 'show', 'fontsize', 14 );
plot( 1:Nmax, t(:,1), 'displayname', 'mat2cell and cat', 'linewidth', 2 );
plot( 1:Nmax, t(:,2), 'displayname', 'loop and reshape', 'linewidth', 2 );
plot( 1:Nmax, t(:,3), 'displayname', 'loop and reshape (2)', 'linewidth', 2 );
plot( 1:Nmax, t(:,4), 'displayname', 'reshape and permute', 'linewidth', 2 );
ylabel( 'Time (sec)' );
xlabel( 'N' );

m = opt3( N, M );

function m = opt1( N, M )
    m = mat2cell(M, N * ones(1, size(M, 1) / N), ...
                    N * ones(1, size(M, 2) / N));
    
    m = cat( 3, m{:} );
end
function m = opt2( N, M )
    m = NaN(N,N,N^2);
    for ii = 1:N:N^2
        m(:,:,ii:(ii+N-1)) = reshape( M(ii:(ii+N-1),:), N, N, N );
    end
end
function m = opt3( N, M )
    m = NaN(N,N,N^2);
    for ii = 1:N:N^2
        m(:,:,ii:(ii+N-1)) = pagetranspose( reshape( M(:,ii:(ii+N-1)).', N, N, N ) );
    end
end
function m = opt4( N, M )
    m = reshape(permute(reshape(M, N,N,N,N), [1,3, 2,4]), N,N, N*N);
end
    • 6

  3. Se você tiver o Image Procressing Toolbox, poderá fazer isso facilmente com im2col(mas o código provavelmente é mais lento que as outras opções):

    S = reshape(im2col(M, [N N], 'distinct'), N, N, []);
    • 2

  4. Isso pode ajudar você?

    m = reshape(M,N,N,N*N);
    • -1

relate perguntas