基于C语言的DCT图像分割

有人能告诉我们如何将图像分割成8X8块吗

我可以读取图像，但不能将其分割为8x8子矩阵进行DCT

int main()
{
    FILE *image_raw;
    unsigned char **matriz_image;
    int i, j;
    int rows=1080, colums=1920;

    matriz_image = (unsigned char  **) malloc (rows*sizeof(unsigned char *));

    //i create dinamic colums
    for(i=0; i<rows; i++)
    {
        matriz_image[i] = (unsigned char *) malloc (colums*sizeof(unsigned char ));
    }

    //i open image raw
    image_raw =  fopen("imag.dat", "r+b");
    //i copy values to matriz_image


    for (i = 0; i < rows; ++i)
    {
        fread(matriz_image[i], sizeof(unsigned char ), colums, image_raw);
    }


    for(i=0; i<rows; i++)
    {
        for(j=0; j<colums; j++)
        {
            // printf("%i ",*(*(matriz_image+i)+j));
            printf("%i ",matriz_image[i][j]);
        }
        printf("\n");
    }

intmain（）
{
文件*image\u raw；
无符号字符**矩阵图像；
int i，j；
整数行=1080，列=1920；
matriz_image=（无符号字符**）malloc（行*sizeof（无符号字符*）；
//我创造了恐龙柱
对于（i=0；i你可以这样做：

void dct(unsigned char **m, int baserow, int basecol)
{
  for (int row = baserow, endrow = baserow + 8; row < endrow; ++row)
    for (int col = basecol, endcol = basecol + 8; col < endcol; ++col)
      ; // operate on m[row][col]
}

int do_dcts(unsigned char **m, int num_rows, int num_cols)
{
  if (num_rows <= 0 || num_rows % 8 || num_cols <= 0 || num_cols % 8)
    return -1;

  for (int row = 0; row < num_rows; row += 8)
    for (int col = 0; col < num_cols; col += 8)
      dct(m, row, col);    

  return 0;
}

如果可以生成行和列常量或具有VLA，则可以执行以下操作：

unsigned char (*m)[colums] = (unsigned char (*)[colums]) matriz_image;

m[5][2] = 2; // double indexed access without extra pointers + allocs

类似地，您可以将指向矩阵的m类指针传递给函数，以便对其进行操作

如果无法将行和列作为编译时常量，并且没有VLA，则可以编写帮助器FCN为您执行指针算术：

inline unsigned char *get_row(unsigned char *m, int numcols, int row)
{
  return &m[row * num_cols];
}

inline unsigned char *get_elem(unsigned char *m, int numcols, int row, int col)
{
  return &m[row * num_cols + col];
}

...

*get_elem(m, colums, 5, 2) = 2;  // double indexing not as nice but good memory usage

如果您确实需要快速执行这些操作，那么在读取图像时，您可以重新组织图像，将8x8字节块连续放置在内存中，以获得最佳缓存性能：

// organize m like m[rows * colums / 64][8][8]; so first index is an 8x8 block #

for (int k = 0; k < rows / 8; ++k)        // read all rows in chunks of 8
  for (int i = 0; i < 8; ++i)             // read 8 rows
    for (int j = 0; j < colums / 8; ++j)  // read 1 row in 8 byte chunks
      fread(&m[k * 8 * colums + i * 8 + j * 64], 1, 8, image_raw);

...

typedef unsigned char (*block_ptr)[8];

inline block_ptr get_block(unsigned char *m, int num_cols, int block_num)
{
  return (block_ptr) &m[block_num * 64];
}

inline block_ptr get_block2(unsigned char *m, int num_cols, int row, int col)
{
  if (row % 8 || col % 8)
    return NULL;

  return (block_ptr) &m[row * num_cols + col * 8];
}

...

for (int k = 0; k < rows * colums / 64; ++k)
{
  block_ptr block = get_block(m, num_colums, k);

  for (int i = 0; i < 8; ++i)
    for (int j = 0; j < 8; ++j)
      ;  // operate on block[i][j];
}

//像m[rows*colums/64][8][8]一样组织m；所以第一个索引是一个8x8块#
for（int k=0；k
您想根据输入创建N个新的、独立的8x8矩阵吗？还是只想在8x8块中处理现有矩阵？我假设没有重叠？非常感谢！您的建议和代码。我看到了我的错误，我会注意的。最后，我为我的英语感到抱歉。
// organize m like m[rows * colums / 64][8][8]; so first index is an 8x8 block #

for (int k = 0; k < rows / 8; ++k)        // read all rows in chunks of 8
  for (int i = 0; i < 8; ++i)             // read 8 rows
    for (int j = 0; j < colums / 8; ++j)  // read 1 row in 8 byte chunks
      fread(&m[k * 8 * colums + i * 8 + j * 64], 1, 8, image_raw);

...

typedef unsigned char (*block_ptr)[8];

inline block_ptr get_block(unsigned char *m, int num_cols, int block_num)
{
  return (block_ptr) &m[block_num * 64];
}

inline block_ptr get_block2(unsigned char *m, int num_cols, int row, int col)
{
  if (row % 8 || col % 8)
    return NULL;

  return (block_ptr) &m[row * num_cols + col * 8];
}

...

for (int k = 0; k < rows * colums / 64; ++k)
{
  block_ptr block = get_block(m, num_colums, k);

  for (int i = 0; i < 8; ++i)
    for (int j = 0; j < 8; ++j)
      ;  // operate on block[i][j];
}