低级的模仿的图像卷积算法

图像处理的基本操作就是矩阵运算了吧，也算是稍微理解下那些算法是怎么操作的

不过后来又看了一下，发现自己写的很幼稚。不管了，先摆出来，以后有时间再看。

#include <iostream>
#include <assert.h>
using namespace std;
#define MAX 100//矩阵最大阶

double Kernel[MAX][MAX] = { 0 };            //卷积核

class Pixel_INMAGE
{
public:
    double Pixel[MAX][MAX];         //像素阵
    double Result[MAX][MAX];            //变换结果矩阵
    //构造
    Pixel_INMAGE()
    {
        memset(Pixel, 0, sizeof(Pixel));
        memset(Result, 0, sizeof(Result));
    }
    //大小比较
    inline int max(int a, int b){ return a > b ? a : b; }
//*********************************************************
//函 数 名：Convolution_One
//参    数：  k    n    m
//         卷积核  行  列
//返 回 值：无
//备    注：压缩卷积
//*********************************************************
    void Convolution_One(int k, int n, int m)   //flag为1
    {
        assert(k <= m && k <= n);               //压缩矩阵
        for (int ROW_OF_RESULT = k / 2; ROW_OF_RESULT < n - k / 2; ROW_OF_RESULT++)
        {
            for (int COL_OF_RESULT = k / 2; COL_OF_RESULT < m - k / 2; COL_OF_RESULT++)
            {
                for (int ROW_OF_PIXEL = ROW_OF_RESULT - k / 2; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)//像素矩阵行,等于号问题也是根据示例调出来的。
                {
                    int ROW_OF_KERNEL = ROW_OF_PIXEL - ROW_OF_RESULT + k / 2;
                    for (int COL_OF_PIXEL = COL_OF_RESULT - k / 2; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                    {
                        int COL_OF_KERNEL = COL_OF_PIXEL - COL_OF_RESULT + k / 2;   //我自己都佩服我自己
                        Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                    }
                }
            }
        }
    }
//*********************************************************
//函 数 名：Convolution_Two
//参    数：  k    n    m
//         卷积核  行  列
//返 回 值：无
//备    注：本来是要分情况考虑的，太碎了，还不如来一个整体的。我认为难点在于等于号的取舍
//*********************************************************
    void Convolution_Two(int k, int n, int m)   //flag为2
    {
        for (int ROW_OF_RESULT = 0; ROW_OF_RESULT < n; ROW_OF_RESULT++)
        {
            for (int COL_OF_RESULT = 0; COL_OF_RESULT < m; COL_OF_RESULT++)
            {
                if (ROW_OF_RESULT - k / 2 >= 0 && COL_OF_RESULT - k / 2 >= 0)//卷积后的result[ROW_OF_RESULT][COL_OF_RESULT]对应的卷积核在Piexl之内
                {
                    for (int ROW_OF_PIXEL = ROW_OF_RESULT - k / 2; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)//像素矩阵行
                    {
                        int ROW_OF_KERNEL = ROW_OF_PIXEL - ROW_OF_RESULT + k / 2;
                        for (int COL_OF_PIXEL = COL_OF_RESULT - k / 2; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = COL_OF_PIXEL - COL_OF_RESULT + k / 2;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
                else if (ROW_OF_RESULT - k / 2 >= 0 && COL_OF_RESULT - k / 2 < 0)//若是像素阵列数为负
                {
                    for (int ROW_OF_PIXEL = ROW_OF_RESULT - k / 2; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)
                    {
                        int ROW_OF_KERNEL = ROW_OF_PIXEL - ROW_OF_RESULT + k / 2;
                        for (int COL_OF_PIXEL = 0; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = k / 2 + COL_OF_PIXEL;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
                else if (ROW_OF_RESULT - k / 2 < 0 && COL_OF_RESULT - k / 2 >= 0)//行数为负
                {
                    for (int ROW_OF_PIXEL = 0; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)
                    {
                        int ROW_OF_KERNEL = k / 2 + ROW_OF_PIXEL;
                        for (int COL_OF_PIXEL = COL_OF_RESULT - k / 2; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = COL_OF_PIXEL - COL_OF_RESULT + k / 2;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
                else            //行数列数全为负
                {
                    for (int ROW_OF_PIXEL = 0; ROW_OF_PIXEL <= ROW_OF_RESULT + k / 2; ROW_OF_PIXEL++)
                    {
                        int ROW_OF_KERNEL = k / 2 + ROW_OF_PIXEL;
                        for (int COL_OF_PIXEL = 0; COL_OF_PIXEL <= COL_OF_RESULT + k / 2; COL_OF_PIXEL++)
                        {
                            int COL_OF_KERNEL = k / 2 + COL_OF_PIXEL;
                            Result[ROW_OF_RESULT][COL_OF_RESULT] += Pixel[ROW_OF_PIXEL][COL_OF_PIXEL] * Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
                        }
                    }
                }
            }
        }
    }
//*********************************************************
//函 数 名：print
//参    数：  k    n    m    CONVOLUTIONAl_FLAG
//         卷积核  行  列    flag
//返 回 值：无
//备    注：输出答案
//*********************************************************
    void print(int k, int n, int m, int CONVOLUTIONAl_FLAG)
    {
        if (CONVOLUTIONAl_FLAG == 1)    //类型一输出，按照计算的时候输出
        {
            for (int ROW_OF_RESULT = k / 2; ROW_OF_RESULT < n - k / 2; ROW_OF_RESULT++)
            {
                for (int COL_OF_RESULT = k / 2; COL_OF_RESULT < m - k / 2; COL_OF_RESULT++)
                {
                    cout << (int)Result[ROW_OF_RESULT][COL_OF_RESULT] << ' ';
                }
                cout << endl;
            }
        }
        else                //类型二输出，图片无压缩
        {
            for (int ROW_OF_RESULT = 0; ROW_OF_RESULT < n; ROW_OF_RESULT++)
            {
                for (int COL_OF_RESULT = 0; COL_OF_RESULT < m; COL_OF_RESULT++)
                {
                    cout << (int)Result[ROW_OF_RESULT][COL_OF_RESULT] << ' ';
                }
                cout << endl;
            }
        }
        Pixel[MAX][MAX] = { 0 };
        Result[MAX][MAX] = { 0 };//矩阵重置为零
        Kernel[MAX][MAX] = { 0 };
    }
//*********************************************************
//函 数 名：Picture_Input
//参    数：   n    m
//             行  列
//返 回 值：无
//备    注：输入图像
//*********************************************************
    void Picture_Input(int n, int m)
    {
        for (int ROW_OF_PIXEL = 0; ROW_OF_PIXEL < n; ROW_OF_PIXEL++)//像素矩阵。
        {
            for (int COL_OF_PIXEL = 0; COL_OF_PIXEL < m; COL_OF_PIXEL++)

                cin >> Pixel[ROW_OF_PIXEL][COL_OF_PIXEL];
        }
    }
};
//*********************************************************
//函 数 名：Kernel_Input
//参    数：  k 卷积核
//返 回 值：无
//备    注：输入卷积核
//*********************************************************
void Kernel_Input(int k)
{
    for (int ROW_OF_KERNEL = 0; ROW_OF_KERNEL < k; ROW_OF_KERNEL++)//卷积核。
    {
        for (int COL_OF_KERNEL = 0; COL_OF_KERNEL < k; COL_OF_KERNEL++)
        {
            cin >> Kernel[ROW_OF_KERNEL][COL_OF_KERNEL];
        }
    }
}
int main()
{
    Pixel_INMAGE Picture;
    int k, n, m, CONVOLUTIONAl_FLAG;//k是k阶卷积核矩阵且k一定是奇数。n是行数，m是列数
    cin >> k >> n >> m >> CONVOLUTIONAl_FLAG;
    assert(k % 2 != 0);     //k坚决不为二
    Picture.Picture_Input(n, m);
    Kernel_Input(k);
    if (CONVOLUTIONAl_FLAG == 1)Picture.Convolution_One(k, n, m);
    else if (CONVOLUTIONAl_FLAG == 2)Picture.Convolution_Two(k, n, m);
    Picture.print(k, n, m, CONVOLUTIONAl_FLAG);
    return 0;
}