im2col

Rearrange image blocks into columns

Syntax

B = im2col(A,[m n],'distinct')

B = im2col(A,[m n],'sliding')

B = im2col(A,[m n])

B = im2col(A,'indexed',___)

Description

B = im2col(A,[m n],'distinct') rearranges discrete image blocks of size m-by-n into columns, and returns the concatenated columns in matrix B. The im2col function pads image A, if necessary. For more information about the padding value, see Tips.

The order of the columns in matrix B is determined by traversing the image A in a column-wise manner. For example, if A consists of distinct blocks Aij arranged as A = [A11 A12; A21 A22], then B = [A11(:) A21(:) A12(:) A22(:)].

B = im2col(A,[m n],'sliding') or

B = im2col(A,[m n]) rearranges sliding image neighborhoods of size m-by-n into columns with no zero-padding, and returns the concatenated columns in matrix B.

B = im2col(A,'indexed',___) interprets A as an indexed image.

Examples

Calculate Local Mean Using [2 2] Neighborhood

Create a matrix.

A = reshape(linspace(0,1,16),[4 4])'

A = 4×4

         0    0.0667    0.1333    0.2000
    0.2667    0.3333    0.4000    0.4667
    0.5333    0.6000    0.6667    0.7333
    0.8000    0.8667    0.9333    1.0000

Rearrange the values into a column-wise arrangement.

B = im2col(A,[2 2])

B = 4×9

         0    0.2667    0.5333    0.0667    0.3333    0.6000    0.1333    0.4000    0.6667
    0.2667    0.5333    0.8000    0.3333    0.6000    0.8667    0.4000    0.6667    0.9333
    0.0667    0.3333    0.6000    0.1333    0.4000    0.6667    0.2000    0.4667    0.7333
    0.3333    0.6000    0.8667    0.4000    0.6667    0.9333    0.4667    0.7333    1.0000

Calculate the mean.

M = mean(B)

M = 1×9

    0.1667    0.4333    0.7000    0.2333    0.5000    0.7667    0.3000    0.5667    0.8333

Rearrange the values back into their original, row-wise orientation.

newA = col2im(M,[1 1],[3 3])

newA = 3×3

    0.1667    0.2333    0.3000
    0.4333    0.5000    0.5667
    0.7000    0.7667    0.8333

Input Arguments

A — Image

2-D grayscale image | 2-D binary image | 2-D indexed image

Image, specified as a 2-D grayscale image, 2-D binary image, or 2-D indexed image.

Data Types: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

[m n] — Block size

2-element vector

Block size, specified as a 2-element vector. m is the number of rows and n is the number of columns in the block.

Output Arguments

B — Image blocks

numeric matrix | logical matrix

Image blocks, returned as a numeric matrix or logical matrix with m*n rows. The number of columns depends on whether the image blocks are discrete blocks or sliding neighborhoods. Each column of B contains a block or neighborhood of A reshaped as a column vector.

• For distinct block processing, B has as many columns as there are m-by-n blocks in A. For example, if the size of A is [mm nn], then B has (mm/m)*(nn/n) columns.

• For sliding neighborhood processing, B has as many columns as there are m-by-n neighborhoods of A. For example, if the size of A is [mm nn], then B has ((mm-m+1)*(nn-n+1)) columns.

Tips

• For distinct block processing, im2col zero-pads A, if necessary, so its size is an integer multiple of m-by-n. The padding value is 0 when A is data type uint8, uint16, or logical. For other data types, the value of padding depends on whether A is interpreted as an indexed image.

  • The padding value is 1 when A is interpreted as an indexed image.

  • The padding value is 0 when A is not interpreted as an indexed image.

• im2col orders the columns of B so that they can be reshaped to form a matrix according to reshape.

  For example, suppose you use a function, such as sum(B), that returns a scalar for each column of B. You can directly store the result in a matrix of size (mm-m+1)-by-(nn-n+1), using these calls.

  B = im2col(A,[m n],'sliding');
  C = reshape(sum(B),mm-m+1,nn-n+1);